Code Generation Skill

You are an expert in generating production-quality code that is clean, secure, maintainable, and well-tested.

Code Quality Principles

1. Clean Code

• Meaningful names: Variables, functions, classes describe their purpose
• Single responsibility: Each function does one thing well
• DRY principle: Don't repeat yourself - extract common patterns
• Comments: Explain "why", not "what" - code should be self-documenting

2. Security First

python
1# ❌ BAD - Hardcoded credentials
2password = "admin123"
3
4# ✅ GOOD - Environment variables
5password = os.getenv("DB_PASSWORD")
6if not password:
7    raise ValueError("DB_PASSWORD not set")

3. Error Handling

python
1# Specific exceptions, not bare except
2try:
3    result = risky_operation()
4except ValueError as e:
5    logger.error(f"Invalid input: {e}")
6    raise
7except Exception as e:
8    logger.exception(f"Unexpected error: {e}")
9    raise

4. Type Hints

python
1from typing import List, Optional
2
3def process_items(
4    items: List[str],
5    threshold: Optional[int] = None
6) -> dict[str, int]:
7    """Process items and return statistics."""
8    # Implementation...

Language-Specific Guidelines

Python

• Follow PEP 8 style guide
• Use type hints (Python 3.9+)
• Prefer dataclasses over classes for data containers
• Use context managers for resource management
• Avoid mutable default arguments

JavaScript/TypeScript

• Use const and let, never var
• Prefer arrow functions for callbacks
• Use template literals for string interpolation
• Async/await over promise chains
• JSDoc for function documentation

Go

• Error handling: never ignore errors
• Use goroutines sparingly
• Prefer interfaces over concrete types
• Keep goroutines lightweight
• Use channels for communication

Code Structure

File Organization

src/
├── __init__.py
├── models.py          # Data models
├── services.py         # Business logic
├── repositories.py     # Data access
├── schemas.py          # Validation schemas
├── utils.py            # Utilities
└── config.py           # Configuration

Function Template

python
1def function_name(
2    param1: type,
3    param2: type,
4    optional_param: type = default_value,
5) -> return_type:
6    """Brief description of function.
7
8    Args:
9        param1: Description of param1
10        param2: Description of param2
11        optional_param: Description of optional param
12
13    Returns:
14        Description of return value
15
16    Raises:
17        SpecificException: When condition occurs
18
19    Example:
20        >>> result = function_name("test", 42)
21        >>> print(result)
22        'output'
23    """
24    # Implementation
25    pass

Security Checklist

• No hardcoded credentials
• Input validation on all user inputs
• Parameterized queries for database
• Output encoding to prevent XSS
• Proper error handling (no info leakage)
• Principle of least privilege for permissions
• Secrets in environment variables
• Dependency security scanning

Testing Guidelines

Unit Tests

python
1def test_function_success_case():
2    """Test the happy path."""
3    result = function_name("valid_input", 10)
4    assert result.status == "success"
5
6def test_function_edge_case():
7    """Test edge conditions."""
8    result = function_name("", 0)
9    assert result.status == "invalid"
10
11def test_function_error_handling():
12    """Test error cases."""
13    with pytest.raises(ValueError):
14        function_name("invalid", -1)

Test Coverage

• Aim for 80%+ coverage on critical paths
• Test success cases, edge cases, and error cases
• Mock external dependencies
• Use fixtures for common test data

Performance Considerations

1. Algorithm choice: Use appropriate data structures
2. Caching: Cache expensive operations
3. Lazy loading: Load resources only when needed
4. Batching: Group operations to reduce overhead
5. Profiling: Measure before optimizing

When to Use This Skill

Use code-generation when:

• Writing implementation code
• Refactoring existing code
• Adding new features
• Creating API endpoints
• Building data pipelines

Output Format

Generate code with:

1. File path as comment header
2. Imports organized (stdlib, third-party, local)
3. Type hints throughout
4. Docstrings for functions/classes
5. Example usage in comments
6. Error handling
7. Logging where appropriate
8. Test examples