Best AI Prompts for Coding

You are a senior {{language}} developer. Implement a function based on the following specification.

Function name: {{function_name}}
Purpose: {{purpose}}
Parameters:
{{parameters}}

Return type: {{return_type}}

Requirements:
- Follow {{language}} best practices and idiomatic style
- Include comprehensive input validation
- Handle edge cases (empty inputs, null values, boundary conditions)
- Add JSDoc/docstring comments explaining parameters, return value, and exceptions
- Write the implementation to be easily unit-testable

If any part of the spec is ambiguous, state your assumption before implementing.

Migrate the following {{source_framework}} code to {{target_framework}}.

Source code:
```{{source_language}}
{{source_code}}
```

Migration requirements:
1. Use idiomatic {{target_framework}} patterns and conventions
2. Preserve all existing functionality and business logic exactly
3. Replace {{source_framework}}-specific APIs with their {{target_framework}} equivalents
4. Update state management to match {{target_framework}} paradigms
5. Maintain the same component/module boundaries where possible
6. Flag any {{source_framework}} features that have no direct {{target_framework}} equivalent and suggest workarounds

Output the migrated code with inline comments where the approach differs from the original.

Create a regular expression in {{language}} that matches the following pattern:

{{pattern_description}}

Examples that SHOULD match:
{{valid_examples}}

Examples that should NOT match:
{{invalid_examples}}

Requirements:
1. Write the regex with named capture groups where meaningful
2. Optimize for readability over brevity (use verbose/extended mode if the language supports it)
3. Provide a line-by-line breakdown explaining each part of the regex
4. Include 3 additional edge-case test strings (with expected match/no-match result) that I should verify
5. Note any known limitations or inputs that could cause catastrophic backtracking

You are a {{database}} performance specialist. Analyze and optimize the following slow query.

Query:
```sql
{{slow_query}}
```

Table schemas (relevant tables):
{{table_schemas}}

Current indexes:
{{existing_indexes}}

Approximate table sizes: {{table_sizes}}

Please provide:
1. Explain why the current query is slow (identify full table scans, missing indexes, N+1 patterns, implicit type casts, etc.)
2. Rewrite the optimized query
3. Recommend any new indexes with CREATE INDEX statements
4. Estimate the expected improvement (order of magnitude)
5. If the query can be restructured (e.g., replacing a subquery with a JOIN, or using a CTE), show both options and explain the tradeoff
6. Flag any risks the optimization introduces (lock contention, index bloat, write performance impact)

Design a robust error handling pattern for the following {{language}} module.

Module purpose: {{module_purpose}}
External dependencies: {{dependencies}}
Failure modes to handle:
{{failure_modes}}

Requirements:
1. Define a custom error hierarchy (base error class + specific subtypes for each failure mode)
2. Each error should carry: error code, human-readable message, original cause (for wrapping), and a serializable context object
3. Implement a centralized error handler that:
   - Logs structured error data (timestamp, error code, stack trace, context)
   - Maps errors to appropriate HTTP status codes (if applicable)
   - Sanitizes error messages for end-user display (no leaking internals)
4. Show example usage: a function that calls an external dependency, catches its errors, wraps them in your custom types, and propagates them
5. Include a retry wrapper for transient failures (network timeouts, rate limits) with exponential backoff

Use {{language}} idioms (e.g., Result types in Rust, checked exceptions in Java, error boundaries in React).

Scaffold a reusable {{framework}} component with the following specification.

Component name: {{component_name}}
Purpose: {{purpose}}
Props/inputs:
{{props}}

Behavior:
{{behavior}}

Requirements:
1. Use TypeScript with strict prop types (no `any`)
2. Include default prop values where sensible
3. Implement accessibility: proper ARIA attributes, keyboard navigation, focus management
4. Add loading and error states with appropriate UI feedback
5. Make the component responsive (mobile-first, works at all breakpoints)
6. Extract reusable logic into a custom hook if the component has non-trivial state
7. Include a usage example showing the component with all major prop combinations
8. Add brief inline comments for any non-obvious logic

Style using {{styling_approach}}.

Generate a {{ci_platform}} pipeline configuration for a {{project_type}} project.

Repository structure: {{repo_structure}}
Language/runtime: {{language}} {{version}}
Deploy target: {{deploy_target}}

The pipeline should include these stages:
1. **Install** - Dependency installation with caching (cache key based on lockfile hash)
2. **Lint & Format** - Run {{linter}} and fail on violations
3. **Type Check** - Run type checking (if applicable)
4. **Test** - Run unit tests with coverage reporting; fail if coverage drops below {{coverage_threshold}}%
5. **Build** - Production build with environment-specific variables
6. **Deploy Staging** - Auto-deploy on push to `develop` branch
7. **Deploy Production** - Deploy on push to `main` with manual approval gate

Additional requirements:
- Use matrix builds for {{test_environments}} if applicable
- Store build artifacts between stages
- Set appropriate timeouts for each stage
- Include a notification step ({{notification_channel}}) on failure
- Add environment-specific secrets management
- Include a rollback step or instructions for production deploys

Perform a technical debt assessment on the following {{language}} codebase module.

Module/file:
```{{language}}
{{code}}
```

Context: This module is part of {{system_description}} and is modified approximately {{change_frequency}}.

Assess the following dimensions and rate each from 1 (minimal debt) to 5 (critical):

1. **Readability** - Naming, structure, comments, cognitive complexity
2. **Maintainability** - Coupling, cohesion, single responsibility adherence
3. **Testability** - Can functions be unit-tested in isolation? Are dependencies injectable?
4. **Error Handling** - Are failure modes covered? Are errors informative?
5. **Performance** - Obvious inefficiencies, unnecessary allocations, N+1 patterns
6. **Security** - Input validation, injection risks, secret handling

For each dimension:
- Provide the rating with a one-line justification
- List specific code locations (function/line) with the issue
- Suggest a concrete fix with estimated effort (hours)

End with a prioritized refactoring plan: what to fix first based on risk and effort, suitable for adding to a sprint backlog.