Best AI Prompts for Coding (2026)

You are a senior Python 3.11 engineer. Write a function called `merge_and_deduplicate` that:

Inputs:
- list_a: list[dict] — each dict has keys "id" (int) and "value" (str)
- list_b: list[dict] — same structure

Output: list[dict] — merged, deduplicated by "id". For duplicate IDs, keep the entry from list_b. Sorted ascending by "id".

Requirements:
- Type hints on the function signature
- O(n) time complexity
- No external libraries (stdlib only)

Output only the function and any needed imports. No explanation.

You are a senior FastAPI engineer. Generate a POST endpoint for user registration.

Route: POST /users/register
Request body: email (str, valid email), password (str, min 8 chars), full_name (str)
Success response: 201 Created — { "user_id": UUID, "email": str, "created_at": ISO8601 }
Error responses: 422 for validation errors (FastAPI default), 409 if email already exists

Include:
- Pydantic request/response models
- Password hashing (passlib bcrypt)
- Duplicate email check raising HTTPException(409)
- Async handler function

No database implementation needed — stub with a dict. Output only the code.

Review the following code as a senior engineer doing a production-readiness check.

For each issue found, format as:
[SEVERITY: Critical/High/Medium/Low] Category: Description → Suggested fix

Severity definitions:
- Critical: will cause data loss, security breach, or crash in production
- High: likely to cause bugs or performance problems under load
- Medium: code smell, maintainability issue, or best-practice deviation
- Low: style, naming, or minor clarity issue

After listing issues, add a 2-sentence overall verdict.

```
[PASTE YOUR CODE HERE]
```

Review the following code for security vulnerabilities. Focus on:
- Injection risks (SQL, command, LDAP, XPath)
- Authentication and authorization flaws
- Sensitive data exposure (tokens, passwords, PII in logs)
- Insecure deserialization
- Missing input validation or output encoding
- Dependency/supply-chain risks

For each issue: describe the vulnerability, explain the attack vector, and provide a concrete fix.

```
[PASTE YOUR CODE HERE]
```

Debug this error. First explain the root cause, then provide the fix.

Error:
```
[PASTE FULL STACK TRACE HERE]
```

Relevant code:
```python
[PASTE MINIMAL REPRODUCING CODE]
```

Expected behavior: [describe what should happen]
Actual behavior: [describe what is happening]
What I've already tried: [list your attempts, even if they didn't work]

Format:
1. Root cause (2–3 sentences)
2. Fixed code (complete, runnable)
3. Why the fix works (1–2 sentences)

Profile this code for performance bottlenecks.

Context: this function runs [N] times per request / processes [X MB] of data / must complete in < [Yms].

```
[PASTE YOUR CODE]
```

For each bottleneck:
- Identify the slow line(s) with a rough complexity estimate (O(n²), O(n) etc.)
- Explain why it's slow at scale
- Provide the optimized version

End with the rewritten function incorporating all fixes.

Write comprehensive pytest unit tests for this function.

```python
[PASTE FUNCTION HERE]
```

Cover:
1. Happy path (typical inputs → expected outputs)
2. Edge cases (empty inputs, boundary values, None/null)
3. Failure modes (invalid types, out-of-range values — expect exceptions)

Use pytest.mark.parametrize for data-driven tests where applicable. Use descriptive test names (test_<function>_<scenario>_<expected_result>). No mocks unless the function has external dependencies.

Output only the test file, no explanation.

Write a Google-style docstring for this Python function. Be concise — 1-line summary, then Args/Returns/Raises sections only if non-obvious. Skip Args/Returns/Raises if the function signature and types make them self-evident.

Do not pad with obvious information ("Returns the result"). Output only the docstring, no surrounding code.

```python
[PASTE FUNCTION HERE]
```