Free AI Developer Resources

You are a senior software engineer debugging a [language] application.

Issue: [describe the symptom]
Error message: [paste error]
Expected behavior: [describe what should happen]

Steps:
1. Analyze the error message and identify the most likely root cause
2. List 3 possible causes, ranked by probability
3. For the most likely cause, explain the fix in detail
4. Show the exact code change needed (diff format)
5. Suggest a test to prevent this from recurring

Write comprehensive unit tests for the following [language] function:

[language] code:
```
[paste function code]
```

Requirements:
- Cover all edge cases (null, empty, boundary values)
- Test both success and failure paths
- Use [testing framework: jest/pytest/go test/etc.]
- Include setup/teardown if needed
- Follow AAA pattern (Arrange, Act, Assert)
- Aim for 100% branch coverage

Refactor the following [language] code for readability and maintainability:

```
[paste messy code]
```

Requirements:
- Extract magic numbers into named constants
- Break functions longer than 20 lines into smaller ones
- Rename variables to be self-documenting
- Remove dead code and unnecessary comments
- Apply [specific design pattern if relevant]
- Preserve existing behavior exactly
- Show before/after diff

Design a REST API endpoint for: [describe feature]

Context:
- Tech stack: [framework/database]
- Auth: [JWT/OAuth/API key]
- Scale: [expected requests/day]

Provide:
1. Endpoint path and HTTP method
2. Request body schema (JSON)
3. Response body schema for 200, 400, 401, 500
4. Validation rules
5. Database queries (if applicable)
6. Rate limiting strategy
7. Example curl request

Review this code change for security vulnerabilities:

```
[paste diff or code]
```

Focus on:
- SQL injection / NoSQL injection
- XSS vulnerabilities
- Authentication/authorization bypasses
- Sensitive data exposure (keys, tokens, PII)
- Input validation gaps
- Insecure dependencies or patterns
- Race conditions

For each issue found, state severity (critical/high/medium/low) and show the fix.

This [SQL/NoSQL] query is slow. Optimize it:

Schema:
```
[paste relevant table schemas]
```

Current query:
```
[paste slow query]
```

Execution plan:
```
[paste EXPLAIN output if available]
```

Provide:
1. Why this query is slow (point to specific lines)
2. The optimized query
3. Suggested indexes (show CREATE INDEX statements)
4. Expected performance improvement
5. Any trade-offs introduced

Write OpenAPI 3.0 documentation for this endpoint:

Language: [language/framework]
Route: [method] [path]
Auth required: [yes/no]
Request body:
```
[paste example]
```
Response:
```
[paste example]
```

Include:
- Operation description
- All parameters with types and descriptions
- Request body schema
- All possible response codes with schemas
- Example request/response in curl
- Any rate limits or special behavior

Write a production-ready Dockerfile for a [language/framework] application.

Requirements:
- Multi-stage build to minimize image size
- Run as non-root user
- Health check endpoint
- Proper signal handling for graceful shutdown
- Layer caching optimization
- Environment variable configuration
- No secrets in image layers

Application entry point: [command]
Port: [port number]
Build dependencies: [list]
Runtime dependencies: [list]

Design a database schema for: [feature description]

Tech: [PostgreSQL/MySQL/MongoDB]
Expected scale: [rows, reads/sec, writes/sec]
Relationships: [describe how entities relate]

Provide:
1. All tables/collections with column types and constraints
2. Primary keys, foreign keys, and indexes
3. Migration strategy (for existing data)
4. Sample queries this schema enables
5. Any denormalization decisions and why

Write an integration client for the [service name] API.

API documentation: [link if available]
Authentication: [API key/OAuth/bearer token]
Language: [language]

Implement:
1. Client class with proper error handling
2. Request retry with exponential backoff
3. Response parsing and type mapping
4. Rate limit handling (respect Retry-After headers)
5. Timeout configuration
6. Example usage for the main endpoint

API endpoints to wrap:
- [GET /resource] — [description]
- [POST /resource] — [description]