## Code Quality Rules
- Follow Go's official style guide and idioms from "Effective Go"
- Use proper error handling with explicit checks (`if err != nil`)
- Prefer composition over inheritance
- Write concise, descriptive function and variable names
- Include appropriate comments for complex logic and exported functions/types
- Use proper package organization and naming
- Implement proper resource cleanup (defer, close, etc.)
- Apply consistent formatting (use gofmt standards)
- Favor readability over excessive optimization
- Use appropriate Go concurrency patterns (goroutines, channels, sync package)

## Architecture and Design Rules
- Follow SOLID principles where applicable
- Use interfaces for flexible and testable code
- Separate concerns (business logic, data access, presentation)
- Design for testability
- Create small, focused packages with clear responsibilities
- Use dependency injection for better testing and flexibility
- Implement proper error types and handling strategies
- Design APIs with consistency and backward compatibility in mind
- Apply appropriate design patterns but avoid over-engineering
- Consider performance implications of design choices

## Testing Rules
- Write comprehensive unit tests for all functionality
- Use table-driven tests for clear and concise test cases
- Implement integration tests for critical paths
- Use appropriate mocks and test doubles
- Test error conditions and edge cases
- Benchmark performance-critical code
- Use Go's built-in testing tools (testing package, benchmarks)
- Practice test-driven development when appropriate
- Keep tests maintainable and understandable
- Ensure adequate test coverage

## Performance and Optimization Rules
- Use appropriate data structures and algorithms
- Profile before optimizing (pprof)
- Optimize for memory efficiency in large-scale systems
- Consider CPU and I/O bound operations
- Use buffered operations for I/O intensive tasks
- Apply concurrency with caution and purpose
- Design for scalability from the beginning
- Minimize allocations in performance-critical paths
- Use sync.Pool for frequent allocations
- Consider cache-friendly data structures

## Security Rules
- Validate all user inputs
- Sanitize data before using in SQL, templates, etc.
- Use secure cryptographic practices
- Implement proper authentication and authorization
- Handle sensitive data carefully (passwords, tokens)
- Use the principle of least privilege
- Check for common security vulnerabilities (OWASP)
- Consider rate limiting for public APIs
- Implement proper logging (without sensitive data)
- Keep dependencies updated and scan for vulnerabilities

## Documentation Rules
- Document all exported functions, types, and constants
- Provide clear package documentation
- Include examples in documentation when helpful
- Document concurrency considerations
- Explain non-obvious design choices
- Document known limitations and edge cases
- Include usage examples for complex APIs
- Keep documentation up-to-date with code changes
- Document error conditions and handling
- Use godoc compatible documentation style