Przejdź do treści
Biblioteka skilli
Programowanie · Nauka i wyjaśnianie

coding-principles

/coding-principles

Przedstawia niezależne od języka zasady kodowania dotyczące utrzymywalności, czytelności i jakości przy implementacji i przeglądzie.

Repozytorium
overture ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Przedstawia niezależne od języka zasady kodowania dotyczące utrzymywalności, czytelności i jakości przy implementacji i przeglądzie.

Wyzwalacze z opisu

clean codebest practicescode qualitymaintainability
Oryginalny opis (EN)

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".

Jak działa

  1. Core Philosophy
  2. Code Quality
  3. Function Design
  4. Error Handling
  5. Dependency Management
  6. Performance Considerations
  7. Code Organization
  8. Commenting Principles
  9. Refactoring Approach
  10. Clean Code Guidelines
Sekcje z nagłówków SKILL.md, w oryginale · 218 linii, 1 039 słów
Podgląd SKILL.md
---
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

Wersje

RepozytoriumWynikLicencja
Ta strona · tundraray/overture100MIT
xoai/sage100MIT
a2ui-project/a2ui100MIT
shinpr/claude-code-workflows100MIT

Migawka bazy z 13.11.2026 · wersja paczki 72bb3f9d9bba (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100code-quality
    Przedstawia zasady jakości kodu, w tym SOLID i DRY, strategie testowania i dobre praktyki przy przeglądzie implementacji.
  • 100code-quality
    Przedstawia zasady jakości kodu, w tym SOLID i DRY, strategie testowania i dobre praktyki przy przeglądzie implementacji.
  • 100coding
    Podaje niezależne od języka konwencje kodowania dotyczące jakości kodu, komentarzy, obsługi błędów i formatowania; konwencje projektu mają pierwszeństwo.
  • 95testing-principles
    Podaje zasady testowania niezależne od języka: TDD, jakość testów, standardy pokrycia i wzorce projektowania testów.
  • 100backend-architecture-principles
    Stosuje zasady architektury backendu niezależne od języka: strukturę kodu, błędy, konfigurację, logi i zadania w tle.
  • 95pact-coding-standards
    Podpowiada zasady czystego kodu, obsługę błędów, logowanie i nazewnictwo w fazie kodowania PACT oraz przy przeglądzie kodu.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.