Coding Principles

What I Do

Provide universal coding principles and best practices that apply across programming languages and project types.

Universal Coding Principles

Code Quality Standards

Maintainability:

• Follow consistent naming conventions
• Use clear, descriptive variable names
• Keep functions focused and single-purpose
• Limit function complexity (cyclomatic complexity < 10)

Readability:

• Use consistent indentation and formatting
• Add meaningful comments for complex logic
• Document public APIs and interfaces
• Follow language-specific style guides

Version Control Best Practices

# Universal git workflow
# Feature branches: feature/<name>
# Bug fixes: fix/<description>
# Documentation: docs/<topic>
# Releases: release/v<version>

# Commit message format
# Type: feat, fix, docs, style, refactor, perf, test, chore
# Scope: optional module/component
# Subject: imperative, present tense, <50 chars
# Body: optional detailed explanation
# Footer: optional breaking changes, issue references

Boolean Flags Implementation

# Universal boolean flag pattern
class FeatureFlags:
    def __init__(self, **flags):
        self._flags = flags

    def is_enabled(self, flag_name):
        return self._flags.get(flag_name, False)

    def enable(self, flag_name):
        self._flags[flag_name] = True

    def disable(self, flag_name):
        self._flags[flag_name] = False

When to Use Me

Use this skill when:

• Establishing coding standards for new projects
• Onboarding new team members
• Creating cross-project consistency
• Implementing maintainable software practices

Universal Examples

Environment Variable Patterns

# Universal environment variable handling
import os
from typing import Optional

def get_env_var(name: str, default: Optional[str] = None) -> str:
    """Get environment variable with validation"""
    value = os.environ.get(name, default)
    if value is None:
        raise ValueError(f"Required environment variable {name} not set")
    return value

Error Handling Patterns

# Universal error handling
def safe_operation(func, *args, **kwargs):
    """Execute function with universal error handling"""
    try:
        return func(*args, **kwargs)
    except Exception as e:
        # Log error with context
        log_error(f"Operation {func.__name__} failed: {str(e)}")
        # Return graceful fallback
        return get_fallback_value(func)

Best Practices

1. Consistency: Apply the same principles across all projects
2. Documentation: Document coding standards clearly
3. Automation: Use linters and formatters to enforce standards
4. Review: Implement code review processes

Compatibility

Applies to:

• All programming languages
• Any software project type
• Cross-project standardization
• Organizational coding guidelines