# Prompt Examples

## Code Review

### Architecture Review
```
Analyze this codebase's architecture:
1. Evaluate the overall structure and patterns
2. Identify potential architectural issues
3. Suggest improvements for scalability
4. Note areas that follow best practices

Focus on maintainability and modularity.
```

### Security Review
```
Perform a security review of this codebase:
1. Identify potential security vulnerabilities
2. Check for common security anti-patterns
3. Review error handling and input validation
4. Assess dependency security

Provide specific examples and remediation steps.
```

### Performance Review
```
Review the codebase for performance:
1. Identify performance bottlenecks
2. Check resource utilization
3. Review algorithmic efficiency
4. Assess caching strategies

Include specific optimization recommendations.
```

## Documentation Generation

### API Documentation
```
Generate comprehensive API documentation:
1. List and describe all public endpoints
2. Document request/response formats
3. Include usage examples
4. Note any limitations or constraints
```

### Developer Guide
```
Create a developer guide covering:
1. Setup instructions
2. Project structure overview
3. Development workflow
4. Testing approach
5. Common troubleshooting steps
```

### Architecture Documentation
```
Document the system architecture:
1. High-level overview
2. Component interactions
3. Data flow diagrams
4. Design decisions and rationale
5. System constraints and limitations
```

## Analysis and Improvement

### Dependency Analysis
```
Analyze the project dependencies:
1. Identify outdated packages
2. Check for security vulnerabilities
3. Suggest alternative packages
4. Review dependency usage patterns

Include specific upgrade recommendations.
```

### Test Coverage
```
Review the test coverage:
1. Identify untested components
2. Suggest additional test cases
3. Review test quality
4. Recommend testing strategies
```

### Code Quality
```
Assess code quality and suggest improvements:
1. Review naming conventions
2. Check code organization
3. Evaluate error handling
4. Review commenting practices

Provide specific examples of good and problematic patterns.
```

## Tips for Better Results

1. **Be Specific**: Include clear objectives and evaluation criteria
2. **Set Context**: Specify your role and expertise level needed
3. **Request Format**: Define how you want the response structured
4. **Prioritize**: Indicate which aspects are most important

## Model-Specific Notes

### Claude
- Use XML output format
- Place important instructions at the end
- Specify response structure

### ChatGPT
- Use Markdown format
- Break large codebases into sections
- Include system role prompts

### Gemini
- Works with all formats
- Focus on specific areas per request
- Use step-by-step analysis
