coding-principles
/coding-principles
This skill provides language-agnostic coding principles for maintainability, readability, and quality. Automatically loaded when implementing features, refactoring code, reviewing code quality, or when the user mentions "clean code", "best practices", "code quality", or "maintainability".
- Author
- tundraray ↗
- Repository
- overture ↗
- Licence
- MIT
- Last repository change
- 07.11.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 07.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
This skill provides language-agnostic coding principles for maintainability, readability, and quality. Automatically loaded when implementing features, refactoring code, reviewing code quality, or when the user mentions "clean code", "best practices", "code quality", or "maintainability".
Triggers from the description
Original author description
This skill provides language-agnostic coding principles for maintainability, readability, and quality. Automatically loaded when implementing features, refactoring code, reviewing code quality, or when the user mentions "clean code", "best practices", "code quality", or "maintainability".
How it works
- Core Philosophy
- Code Quality
- Function Design
- Error Handling
- Dependency Management
- Performance Considerations
- Code Organization
- Commenting Principles
- Refactoring Approach
- Clean Code Guidelines
SKILL.md preview
--- name: coding-principles description: This skill provides language-agnostic coding principles for maintainability, readability, and quality. Automatically loaded when implementing features, refactoring code, reviewing code quality, or when the user mentions "clean code", "best practices", "code quality", or "maintainability". --- # Language-Agnostic Coding Principles ## Core Philosophy 1. **Maintainability over Speed**: Prioritize long-term code health over initial development velocity 2. **Simplicity First**: Choose the simplest solution that meets requirements (YAGNI principle) 3. **Explicit over Implicit**: Make intentions clear through code structure and naming 4. **Delete over Comment**: Remove unused code instead of commenting it out The sizes in this skill (parameters, function and file length, nesting) are signals to look again, not limits: past one, consider a split; keep the code as it is when splitting would make it harder to read. ## Code Quality ### Continuous Improvement - Refactor as you go - don't accumulate technical debt - Improve code structure incrementally - Keep the codebase lean and focused - Delete code your change leaves unused ### Readability - Use meaningful, descriptive names for variables and functions - Avoid abbreviations unless they are widely recognized - Keep code self-documenting where possible - Write code that humans can easily understand ## Function Design ### Parameter Management - **Recommended**: 0-2 parameters per function - **For 3+ parameters**: Use objects, structs, or dictionaries to group related parameters - **Example** (conceptual): ``` // Instead of: createUser(name, email, age, city, country) // Use: createUser(userData) ``` ### Single Responsibility - Each function should do one thing well - Keep functions small and focused (typically < 50 lines) - Extract complex logic into separate, well-named functions - Functions should have a single level of abstraction ### Function Organization - Pure functions when possible (no side effects) - Separate data transformation from side effects - Use early returns to reduce nesting - Avoid deep nesting (beyond 3 levels is a signal) ## Error Handling ### Error Management Principles - **Always handle errors**: Log with context or propagate explicitly - **Log appropriately**: Include context for debugging - **Protect sensitive data**: Mask or exclude passwords, tokens, PII from logs - **Fail fast**: Detect and report errors as early as possible ### Error Propagation - Use language-appropriate error handling mechanisms - Propagate errors to appropriate handling levels - Provide meaningful error messages - Include error context when re-throwing ## Dependency Management ### Loose Coupling - Inject external dependencies as parameters - Avoid direct imports within functions when possible - Depend on abstractions, not concrete implementations - Minimize inter-module dependencies ### Parameterized Dependencies - Pass dependencies explicitly through function parameters - Use constructor parameter injection for class-based languages - Use function parameters for functional/procedural approaches - Facilitate testing through mockable dependencies ## Performance Considerations ### Optimization Approach - **Measure first**: Profile before optimizing - **Focus on algorithms**: Algorithmic complexity > micro-optimizations - **Use appropriate data structures**: Choose based on access patterns - **Resource management**: Handle memory, connections, and files properly ### When to Optimize - After identifying actual bottlenecks - When performance issues are measurable - Not prematurely during initial development ## Code Organization ### Structural Principles - **Group related functionality**: Keep related code together - **Separate concerns**: Domain logic, data access, presentation - **Consistent naming**: Follow project conventions - **Module cohesion**: High cohesion within modules, low coupling between ### File Organization - One primary responsibility per file - Logical grouping of related functions/classes - Clear folder structure reflecting architecture - Avoid "god files" (files > 500 lines) ## Commenting Principles ### When to Comment - **Explain "why"**: Clarify reasoning behind decisions - **Note limitations**: Document known constraints or edge cases - **API documentation**: Public interfaces need clear documentation ### When NOT to Comment - Avoid describing "how" (the code shows that) - Don't include historical information (use version control) - Remove commented-out code (use git to retrieve old code) - Avoid obvious comments that restate the code ### Comment Quality - Keep comments concise and timeless - Update comments when changing code - Use proper grammar and formatting - Write for future maintainers ## Refactoring Approach ### Safe Refactoring - **Small steps**: Make one change at a time - **Maintain working state**: Keep tests passing - **Verify behavior**: Run the affected tests after each change - **Incremental improvement**: Don't aim for perfection immediately ### Refactoring Triggers - Code duplication (DRY principle) - Functions > 50 lines - Complex conditional logic - Unclear naming or structure ## Clean Code Guidelines ### Naming Conventions - Use domain language in names - Be specific and descriptive - Avoid single-letter names (except loop counters) - Follow language-specific conventions (camelCase, snake_case, etc.) ### Code Structure - Prefer early returns over nested conditionals - Extract magic numbers into named constants - Remove debug statements before committing - Keep functions at a single level of abstraction ### Code Smells to Avoid - Long parameter lists - Deeply nested conditionals - Duplicated code blocks - Unclear variable names - Large modules, classes, or functions ## Testing Considerations ### Testability - Write testable code from the start - Avoid hidden dependencies - Keep side effects explicit - Design for parameterized dependencies ### Test-Driven Development - Write tests before implementation when appropriate - Keep tests simple and focused - Test behavior, not implementation - Maintain test quality equal to production code ## Security Principles ### General Security - Store secrets in environment variables or secret managers - Validate all external input - Use parameterized queries for databases - Follow principle of least privilege ### Data Protection - Encrypt sensitive data at rest and in transit - Sanitize user input - Avoid logging sensitive information - Use secure random generators for security-critical operations ## Documentation ### Code Documentation - Document public APIs and interfaces - Include usage examples for complex functionality - Maintain README files for modules - Keep documentation in sync with code ### Architecture Documentation - Document high-level design decisions - Explain integration points - Clarify data flows and boundaries - Record trade-offs and alternatives considered ## Version Control Practices ### Commit Practices - Make atomic, focused commits - Write clear, descriptive commit messages - Commit working code (passes tests) - Avoid committing debug code or secrets ## Language-Specific Adaptations While these principles are language-agnostic, adapt them to your specific programming language: - **Static typing**: Use strong types when available - **Dynamic typing**: Add runtime validation - **OOP languages**: Apply SOLID principles - **Functional languages**: Prefer pure functions and immutability - **Concurrency**: Follow language-specific patterns for thread safety
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · tundraray/overture | 100 | MIT |
| xoai/sage | 100 | MIT |
| a2ui-project/a2ui | 100 | MIT |
| shinpr/claude-code-workflows | 100 | MIT |
Database snapshot: 13.11.2026 · package version 72bb3f9d9bba (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100code-quality
Provides code quality principles including SOLID, DRY, testing strategies, and best practices for implementation review. Use when reviewing code or applying quality standards. - 100code-quality
Provides code quality principles including SOLID, DRY, testing strategies, and best practices for implementation review. Use when reviewing code or applying quality standards. - 100coding
This skill should be used when writing or reviewing code in any language. Provides language-agnostic coding conventions for code quality, comments, error handling, and formatting. Project-specific conventions always take priority. - 95testing-principles
This skill provides language-agnostic testing principles including TDD, test quality, coverage standards, and test design patterns. Automatically loaded when writing tests, designing test strategies, reviewing test quality, or when the user mentions "TDD", "test coverage", "unit… - 100backend-architecture-principles
Language-agnostic backend architecture and code-quality rules. Use when designing services, structuring a backend codebase, writing business logic, handling errors, configuration, logging, background jobs, or reviewing backend code for maintainability. - 95pact-coding-standards
Clean code principles, error handling patterns, and coding standards for PACT Code phase. Use when: implementing features, refactoring code, reviewing code quality, establishing coding conventions, or handling errors and exceptions. Triggers on: code quality, clean code,…