AgentSkillsCN

development-standards

开发标准和最佳实践。当需要开发标准指导时使用。

SKILL.md
--- frontmatter
name: development-standards
description: Development standards and best practices. Use when development standards guidance is required.

Purpose

Provide development standards and best practices that can be applied consistently across languages to improve maintainability, readability, and correctness in new and existing code.

IO Semantics

Input: Codebases, configuration files, and development workflows that require consistent standards.

Output: Concrete naming, structure, performance, and review expectations that can be enforced via linters, CI pipelines, and manual reviews.

Side Effects: When applied, may require refactoring existing code, updating style guides, and adjusting linters or CI configurations.

Deterministic Steps

1. Naming Convention Enforcement

Enforce identifier naming rules consistently:

Variables and Functions:

  • •Use camelCase for JavaScript/TypeScript variables and functions
  • •Use snake_case for Python variables and functions
  • •Use PascalCase for Go public functions and variables
  • •Use descriptive, meaningful names that reveal intent

Classes and Types:

  • •Use PascalCase for class names in all languages
  • •Use descriptive names that indicate purpose and behavior
  • •Avoid abbreviations unless widely understood
  • •Apply consistent prefixes for related concepts

Constants and Configuration:

  • •Use UPPER_SNAKE_CASE for constants
  • •Use descriptive names for configuration values
  • •Group related constants in logical structures
  • •Avoid magic numbers and string literals

Perform naming consistency validation:

  • •Use linters with naming convention rules
  • •Configure language-specific style guides
  • •Apply naming convention checks in CI/CD
  • •Enforce consistent naming across interfaces

2. Code Structure Principles

Apply single responsibility and modularity principles systematically:

Single Responsibility Principle:

  • •Each function performs one clear action
  • •Each class represents one concept
  • •Keep functions under 20 lines when possible
  • •Use composition over inheritance

Open/Closed Principle:

  • •Design for extension through interfaces
  • •Use abstract classes for common behavior
  • •Implement plugin architectures
  • •Avoid modifying existing code for new features

Enforce clean module boundaries and dependency management:

  • •Define clear interfaces between modules
  • •Use dependency injection for loose coupling
  • •Apply the dependency inversion principle
  • •Organize code in logical packages/modules

Module organization patterns:

  • •Group related functionality together
  • •Separate concerns into different layers
  • •Use consistent import/export patterns
  • •Implement proper abstraction levels

3. Performance Optimization Guidelines

Apply appropriate algorithmic complexity:

  • •Use O(1) for constant-time operations
  • •Apply O(log n) for search operations where possible
  • •Use O(n) for linear operations
  • •Avoid O(n²) algorithms for large datasets

Memory optimization techniques:

  • •Use appropriate data structures for the problem
  • •Implement object pooling for frequently created objects
  • •Apply streaming for large data processing
  • •Use lazy loading for expensive operations

Code Performance Profiling

Implement systematic performance analysis:

  • •Profile critical code paths regularly
  • •Measure before and after optimizations
  • •Focus on actual bottlenecks, not premature optimization
  • •Document performance characteristics and limits

Performance monitoring integration:

  • •Add performance metrics to critical functions
  • •Implement benchmarking for regression detection
  • •Use performance budgets for new features
  • •Monitor production performance continuously

Defensive Programming Implementation

Input Validation and Error Handling

Comprehensive Input Validation

Validate all external inputs at boundaries:

  • •Check for null/None/undefined values
  • •Validate data types and ranges
  • •Sanitize string inputs for security
  • •Implement schema validation for structured data

Boundary condition handling:

  • •Handle empty collections and edge cases
  • •Validate array indices and string lengths
  • •Check for numeric overflow/underflow
  • •Implement proper default value handling

Robust Error Handling

Implement systematic error handling:

  • •Use language-specific error handling mechanisms
  • •Provide meaningful error messages
  • •Implement error recovery strategies
  • •Log errors with appropriate context

Exception management patterns:

  • •Catch specific exceptions, not general ones
  • •Implement custom exception types for domain errors
  • •Use fail-fast principles for unrecoverable errors
  • •Apply circuit breaker patterns for external dependencies

Code Maintainability Standards

Documentation and Comments

Write self-documenting code:

  • •Use meaningful variable and function names
  • •Structure code to reveal intent
  • •Add comments for complex business logic
  • •Document API contracts and invariants

Comment quality standards:

  • •Explain why, not what
  • •Keep comments current with code changes
  • •Use consistent comment formatting
  • •Avoid obvious or redundant comments

Code Organization and Structure

Apply consistent code organization:

  • •Use consistent indentation and formatting
  • •Group related code together
  • •Implement proper file/module organization
  • •Use standard design patterns appropriately

Code readability practices:

  • •Keep functions focused and small
  • •Use meaningful variable names
  • •Avoid deep nesting and complex control flow
  • •Implement proper abstraction levels

Quality Assurance Integration

Code Review Standards

Systematic Review Process

Implement comprehensive code reviews:

  • •Review for functionality and correctness
  • •Check for security vulnerabilities
  • •Validate performance characteristics
  • •Ensure adherence to coding standards

Review effectiveness metrics:

  • •Track defect detection rates
  • •Monitor review time and quality
  • •Collect feedback on review process
  • •Implement review checklists

Automated Quality Checks

Integrate automated quality tools:

  • •Static analysis for bug detection
  • •Complexity analysis for maintainability
  • •Security scanning for vulnerability detection
  • •Performance testing for regression detection

Quality gate implementation:

  • •Define quality thresholds for code metrics
  • •Implement automated quality gates in CI/CD
  • •Block deployments on quality failures
  • •Provide actionable feedback for fixes

Technical Debt Management

Debt Identification and Tracking

Systematically identify technical debt:

  • •Track code complexity metrics
  • •Monitor test coverage gaps
  • •Identify outdated dependencies
  • •Document performance limitations

Technical debt prioritization:

  • •Assess impact on business value
  • •Evaluate maintenance cost implications
  • •Consider security and compliance requirements
  • •Plan debt reduction activities

Refactoring Implementation

Apply systematic refactoring:

  • •Use automated refactoring tools when possible
  • •Maintain test coverage during refactoring
  • •Refactor in small, incremental steps
  • •Document architectural decisions and changes

Refactoring validation:

  • •Run comprehensive test suites after refactoring
  • •Validate performance characteristics
  • •Ensure functionality remains unchanged
  • •Update documentation as needed