Gemini Code Generation Patterns: Language-Specific Prompts

LANGUAGE: Python 3.12+
DEPENDENCIES: Standard library only (no external packages)
STYLE: PEP 8, type hints required, Google-style docstrings
CONSTRAINTS:
- No classes unless the task explicitly requires OOP
- Handle edge cases explicitly (empty input, None, large inputs)
- Include error handling for all I/O operations
OUTPUT: Complete, runnable code with a usage example

TASK: [your specific requirement]

LANGUAGE: Python 3.11+
CONSTRAINTS:
- Use dataclasses for data containers, not plain dicts
- Prefer pathlib over os.path
- Use f-strings, not .format() or % formatting
- Use match/case for complex branching (3+ conditions)
- Type hints on all function signatures
- Use collections.abc for type hints (Iterable, Sequence, etc.)
- Handle Unicode properly: always specify encoding='utf-8'

TASK: Write a function that parses a CSV file of sales data
and returns the top N products by revenue, with error handling
for malformed rows and missing files.

LANGUAGE: TypeScript 5.4+ (strict mode)
RUNTIME: Node.js 22
PACKAGES: No external dependencies
STYLE:
- Prefer const over let; never use var
- Use arrow functions for callbacks; named functions for exports
- Use async/await, not raw Promises
- Prefer Array methods (map, filter, reduce) over for-loops
- Use optional chaining (?.) and nullish coalescing (??)
- Export named functions, not default exports

TASK: Create a rate-limited API client with exponential backoff,
request deduplication, and type-safe response handling.

LANGUAGE: Go 1.22+
STYLE:
- Standard Go formatting (gofmt)
- Error handling: always check errors, wrap with fmt.Errorf("%w", err)
- Use context.Context for cancellation in all I/O functions
- Prefer explicit over clever — no reflection unless necessary
- Use interfaces where they clarify intent, not where they add abstraction
- Table-driven tests with testify/assert for test helpers

TASK: Implement a concurrent file processor that walks a directory
tree, processes files in parallel with a worker pool, and collects
results with proper error propagation and context cancellation.

LANGUAGE: Rust (edition 2021)
DEPENDENCIES: tokio (async runtime), serde (serialization), anyhow (error handling)
STYLE:
- Use thiserror for library error types; anyhow for application code
- Prefer &str over String for function parameters
- Use iterators and combinators over manual loops
- Derive Debug, Clone, PartialEq on all public types
- Use Result<T, E> for fallible operations; avoid unwrap() in library code

TASK: Create an async HTTP client wrapper with connection pooling,
automatic retries, and JSON deserialization with proper error types.

DIALECT: PostgreSQL 16
STYLE:
- Explicit JOIN syntax (no implicit joins in WHERE)
- CTEs (WITH clauses) for complex queries over subqueries
- Meaningful table aliases (emp for employees, not t1)
- UPPERCASE for SQL keywords; lowercase for identifiers
- Include comments for non-obvious business logic
- Use COALESCE for nullable columns in calculations

TASK: Write a query that computes monthly recurring revenue (MRR)
from a subscriptions table with upgrades, downgrades, and churn,
accounting for partial months and plan changes.

I'm getting the following error in my [language] application:

[FULL ERROR TRACE]

Here's the relevant code:

[CODE THAT PRODUCES THE ERROR]

Here's what I expected to happen:
[EXPECTED BEHAVIOR]

Please:
1. Explain what the error means in plain language
2. Identify the root cause in the code
3. Provide a fix with the exact code change
4. Explain why the fix works
5. Suggest how to prevent similar errors (test, validation, type system)

Do not suggest refactoring unrelated code. Focus on the error.

Refactor the following code to improve [readability/performance/maintainability]:

[CODE]

Constraints:
- Preserve the existing public API (function signatures, return types)
- Do not change behavior for any valid input
- Add type hints where missing
- Break functions longer than 30 lines into smaller functions
- Extract magic numbers into named constants
- Add docstrings for any new functions created

Provide:
1. The refactored code
2. A summary of changes made
3. Any behavior changes (should be none — flag if unavoidable)

Generate comprehensive tests for the following function:

[FUNCTION CODE]

Test requirements:
- Framework: pytest (Python) / Jest (TypeScript) / go test (Go)
- Cover all code paths visible in the function
- Include edge cases: empty input, None/null, maximum values, Unicode
- Include a test for each documented exception/error condition
- Use parametrized tests where multiple similar cases exist
- Include a performance regression test if the function could be slow

Output format:
- Test file with imports and all test functions
- A comment at the top summarizing test coverage