mbgsec

⭐ 45.5K

When working with configurations that require sensitive data (credentials, tokens, passwords), always use environment…

Configurations

Prevent sensitive data exposure

⭐ 7.7K

Never log or store sensitive information (passwords, tokens, secrets) in clear text. This common security vulnerabili…

Security

Optimize allocation hotspots

⭐ 34.2K

Identify and optimize object allocation in performance-critical paths by applying appropriate allocation strategies b…

Performance Optimization

Extract for clarity

⭐ 73.1K

Extract complex or reused logic into focused, well-named methods with single responsibilities. This improves code rea…

Code Style

Protect sensitive data

⭐ 7.7K

Never log, display, or store sensitive information like passwords, tokens, or secrets in clear text. This creates sig…

Security

Comprehensive documentation standards

⭐ 22.1K

Create clear, well-structured API documentation following proper formatting, correct references, informative examples…

Documentation

Use specific assertion methods

⭐ 34K

Choose the appropriate assertion method based on the data type being tested. This improves test readability and provi…

Testing

Optimize regex patterns

⭐ 1.9K

When using regular expressions, optimize for both performance and precision to ensure efficient and accurate pattern …

Algorithms

Consistent naming patterns

⭐ 2.8K

Follow consistent naming conventions throughout the codebase to improve readability and maintainability:

1. **Client…

Naming Conventions

Handle async operation errors

⭐ 8.3K

Always wrap asynchronous operations in try-catch-finally blocks to prevent unhandled promise rejections and ensure pr…

Error Handling

Keep CI configurations minimal

⭐ 33.8K

When configuring CI workflows, include only the extensions, tools, and settings that are necessary for the specific t…

CI/CD

Spring code style

⭐ 58.4K

Follow Spring Framework’s code style guidelines to ensure consistency across the codebase. Key rules include:

1. **I…

Code Style

Code for readability

⭐ 82.9K

Prioritize human readability when writing code. Split complex expressions into steps with meaningful variable names. …

Code Style

Descriptive consistent naming

⭐ 32.9K

Use descriptive, consistent naming that follows language and platform conventions. Choose names that clearly communic…

Naming Conventions

Clean up your code

⭐ 14K

Maintain clean, professional code by removing development artifacts and improving readability:

1. **Remove debug cod…

Code Style

Design interfaces, not implementations

⭐ 62.1K

Create intuitive API interfaces that abstract away implementation details while providing a consistent experience for…

API

Use testify assertion libraries

⭐ 19.8K

Replace manual if-error checks with `testify`’s `assert` and `require` packages to make tests more readable, maintain…

Testing

Eliminate redundant constructs

⭐ 20.8K

Remove unnecessary coding patterns that add complexity without providing value. Focus on clarity and simplicity by:

…

Code Style

Limit token permissions

⭐ 7.9K

Always specify the minimum required permissions for the GITHUB_TOKEN in GitHub Actions workflows to enhance security….

Security

⭐ 91.3K

Avoid hardcoding specific device types like ‘cuda’ in AI code. Instead, use device-agnostic approaches such as device…

Craft actionable errors

⭐ 25.9K

Create error messages that provide precise context, avoid unnecessary details, and give users clear actions to take. …

Error Handling

Idempotent error-safe disposers

⭐ 112.2K

When implementing resource cleanup logic, especially disposers for explicit resource management, always design for re…

Error Handling

Follow modern C++ guidelines

⭐ 1.4K

Adhere to the C++ Core Guidelines for improved code quality, readability, and maintainability. Follow these key pract…

Code Style

Names express clear intent

⭐ 50.9K

Choose names that clearly express intent and follow established conventions. Prefer explicit, descriptive names over …

Naming Conventions

Sanitize all inputs

⭐ 8.3K

Properly sanitize or escape all user-provided inputs before using them in sensitive contexts to prevent injection att…

Security

Standardize platform-agnostic configuration

⭐ 62.1K

Ensure configuration handling is consistent and platform-agnostic by following these guidelines:

1. Use environment …

Configurations

Document code thoroughly

⭐ 51.7K

Always include comprehensive documentation for your code through both docstrings and explanatory comments.

For clas…

Documentation

Use proper types

⭐ 190.6K

Maintain code clarity by using appropriate type declarations and parameter passing conventions:

1. **Prefer explicit…

Code Style

Complete API documentation

⭐ 58.4K

Documentation should be complete, accurate, and follow Spring Framework conventions. Ensure your Javadocs include:

1…

Documentation

Purposeful documentation standards

⭐ 1.9K

Documentation should convey purpose and behavior, not just replicate code structure. Each docblock should explain wha…

Documentation

Standardize configuration paths

⭐ 14.7K

Follow consistent patterns for storing and referencing configuration files across projects. Place custom configuratio…

Configurations

Next.js directory structure

⭐ 11.8K

Keep the Next.js `/app` directory strictly for routing purposes as per framework conventions. Non-routing related cod…

Code Style

Safe null handling

⭐ 34.3K

Always implement robust null handling patterns to prevent unexpected behavior and crashes. Consider all edge cases wh…

Null Handling

Extract duplicated code

⭐ 34.3K

Identify and extract duplicated code into reusable functions or move common fields to parent structures. This makes t…

Code Style

Consistent descriptive naming

⭐ 82.9K

Use clear, descriptive names that follow consistent patterns established in the codebase and broader programming stan…

Naming Conventions

TypeScript naming standards

⭐ 15K

Follow consistent naming conventions in TypeScript to improve code clarity, type safety, and developer experience:

1…

Naming Conventions

Naming Conventions

Prefer explicit nil handling

⭐ 44.2K

Handle nil values explicitly and consistently to improve code clarity and type safety. Follow these guidelines:

1. U…

Null Handling

Type-safe flexible APIs

⭐ 22.1K

Design APIs that favor both type safety and flexibility. Use strongly typed wrappers instead of primitive types, but …

API

Consistent semantic naming

⭐ 15.6K

Use clear, consistent, and semantic naming patterns across your codebase to improve readability and maintainability: …

Naming Conventions

Prefer idiomatic Option handling

⭐ 62.1K

When handling null values in Rust, use idiomatic Option patterns instead of verbose nested conditionals. This improve…

Null Handling

Avoid magic numbers

⭐ 51.7K

Replace hardcoded values and magic numbers in AI model code with named constants or configuration parameters. This im…

Propagate errors with context

vercel/turborepo

⭐ 28.1K

Properly propagate errors to callers with sufficient context rather than handling them prematurely or hiding them. Le…

Error Handling

Release locks before waking

⭐ 29K

In concurrent systems, it’s critical to release locks before performing operations that might trigger reentrancy or b…

Concurrency

Use consistent error handling

⭐ 190.6K

Apply standardized error handling patterns across your codebase for improved reliability and debugging. For new code,…

Error Handling

Preserve API compatibility

⭐ 77.6K

When evolving APIs, maintain backward compatibility to avoid breaking client code. Consider these guidelines:

1. **A…

API

Descriptive identifier naming

⭐ 1.9K

Choose meaningful, self-explanatory names for variables, parameters, properties, and methods that clearly convey thei…

Naming Conventions

Specific exceptions with context

⭐ 16.6K

Always throw the most specific exception type appropriate for the error condition and include contextual information …

Error Handling

Optimize memory access

⭐ 16.6K

When implementing performance-critical algorithms, carefully consider memory access patterns. Document alignment assu…

Algorithms

Follow naming patterns

⭐ 16.6K

Maintain consistent naming patterns throughout your code to improve readability and maintainability. Follow these gui…

Naming Conventions

Self-documenting identifier names

⭐ 57K

Use clear, self-documenting names for variables, methods, and classes that express intent without exposing unnecessar…

Naming Conventions

Layer security defenses

⭐ 57K

Implement multiple layers of security throughout your application rather than relying on a single protection mechanis…

Security

Verify token security level

⭐ 14.7K

When refreshing or updating authentication tokens, always verify the new token maintains or exceeds the original toke…

Security

Appropriate error handling

⭐ 34.3K

Distinguish between implementation errors (invariant violations) and expected failure cases. For implementation error…

Error Handling

Semantic over generic names

⭐ 34.2K

Choose specific, descriptive names that clearly convey purpose over generic or abbreviated identifiers. Names should …

Naming Conventions

Document public APIs

⭐ 34.2K

All public-facing APIs must be thoroughly documented with clear javadocs. This includes:

1. **Classes and interfaces…

Documentation

Explicit default configurations

⭐ 71.8K

Always provide explicit default values for configuration options to improve code readability and maintainability. Use…

Configurations

Choose meaningful identifier names

⭐ 71.8K

Names for variables, methods, and classes should be descriptive, semantically accurate, and consistent with establish…

Naming Conventions

Sync documentation with code

⭐ 13.6K

Always ensure documentation and comments accurately reflect the actual code implementation. When modifying code, upda…

Documentation

Use transactions for consistency

⭐ 8.3K

Always wrap multiple related database operations in a transaction to ensure data consistency and prevent partial upda…

Database

Remove commented code

⭐ 8.3K

Commented-out code should be removed from the codebase rather than left as comments. Keeping commented code:

1. Clut…

Code Style

Fail gracefully always

⭐ 7.9K

Ensure code handles errors robustly by using protective patterns that prevent resource leaks, provide clear diagnosti…

Error Handling

⭐ 7.7K

Always use the `.get()` method with appropriate default values when accessing dictionaries instead of direct key acce…

Null Handling

Centralize environment variables

⭐ 7.7K

All environment variables should be defined in a centralized location (`checkov/common/util/env_vars_config.py`) rath…

Configurations

Documentation quality standards

⭐ 5.8K

Ensure documentation is specific, complete, and actionable for developers:

1. **Provide meaningful content** - Avoid…

Documentation

Axum Code Review: Interaction Patterns

⭐ 22.1K

When implementing Axum-based applications, it is crucial to ensure that the interaction patterns between components a…

Axum

Vectorize over Python loops

⭐ 51.7K

Replace Python loops and list comprehensions with vectorized operations when processing tensors or performing repeate…

Performance Optimization

Catch specific exception types

⭐ 51.7K

Avoid using broad exception handlers like `except Exception:` or bare `except:`. Instead, catch specific exception ty…

Error Handling

Prevent concurrent access races

⭐ 19.8K

When sharing data across goroutines, always use proper synchronization mechanisms to prevent race conditions. Race co…

Concurrency

Meaningful consistent naming

⭐ 19.8K

Use descriptive, semantically clear names that follow consistent patterns throughout the codebase. Names should conve…

Naming Conventions

Names should be descriptive

⭐ 60.3K

Use clear, descriptive names while avoiding redundant qualifiers. Choose full words over abbreviations unless the abb…

Naming Conventions

Clear precise documentation

⭐ 60.3K

Documentation should use direct, precise language that accurately describes components and their behavior. Maintain c…

Documentation

Validate configurations comprehensively

vercel/turborepo

⭐ 28.1K

When implementing configuration systems, ensure comprehensive validation, testing, and documentation. Key requirement…

Configurations

Descriptive, unambiguous identifiers

vercel/turborepo

⭐ 28.1K

Choose names that clearly express intent and behavior while avoiding ambiguity. Identifiers should communicate their …

Naming Conventions

Write focused single-purpose tests

⭐ 29K

Break down large test cases into smaller, focused tests that each verify a single feature or behavior. Each test shou…

Testing

Optimize algorithmic complexity

⭐ 29K

Always consider the time and space complexity implications of your code. Choose data structures and algorithms that m…

Algorithms

Return results not panics

huggingface/tokenizers

⭐ 9.9K

Libraries should never panic as this can crash applications using the library. Always return a `Result` type rather t…

Error Handling

Descriptive specific names

⭐ 58.4K

Choose names that are specific, descriptive, and accurately reflect the purpose and domain of variables, methods, cla…

Naming Conventions

Optimize test case design

⭐ 77.6K

Write focused, efficient tests that validate core functionality without unnecessary complexity. Key principles:

1. T…

Testing

Follow consistent style conventions

⭐ 77.6K

Spring Boot projects maintain specific coding style conventions for consistency and readability. When contributing co…

Code Style

Explicit security configurations

⭐ 77.6K

When configuring security-related features, always use the most specific configurer classes to make security decision…

Security

Precise type narrowing

⭐ 40.6K

Implement sound type narrowing algorithms that balance precision with correctness. When narrowing types:

1. For dire…

Algorithms

Organize tests for clarity

⭐ 57K

Structure tests to maximize clarity and maintainability by: 1. Placing related tests together in appropriate test fil…

Testing

Optimize numerical precision

⭐ 91.3K

When implementing AI operations that involve matrix multiplication or neural network components, explicitly support m…

Use configurable default values

⭐ 11.8K

Make configuration values flexible and robust by avoiding hardcoded values and providing sensible defaults. This ensu…

Configurations

Specific exception handling

⭐ 11.8K

Handle exceptions with specificity rather than using broad catch-all blocks. Catch specific exception types, provide …

Error Handling

Separate configuration lifecycles

⭐ 25.9K

Maintain clear separation between different stages of configuration processing by creating dedicated structures for e…

Configurations

Log effectively for debugging

⭐ 25.9K

Always include meaningful log messages at appropriate levels to aid in debugging and system monitoring. Follow these …

Logging

Document intent and limitations

⭐ 25.9K

Clearly document the intended purpose, scope limitations, and design decisions in your code. For all exported types, …

Documentation

Follow GoDoc conventions

⭐ 145.7K

Document code following Go’s official documentation style guide (https://tip.golang.org/doc/comment). All exported fu…

Documentation

Descriptive balanced naming

⭐ 145.7K

Choose identifier names that clearly communicate their purpose while maintaining an appropriate balance between brevi…

Naming Conventions

Use specific assertions

⭐ 2.8K

Always write assertions that verify specific, expected values rather than simple existence or boolean checks. This en…

Testing

Document public API elements

⭐ 2.8K

Every public API element (classes, methods, properties, constructors) must have XML documentation comments that clear…

Documentation

Informative error messages

⭐ 112.2K

Error messages should be specific, actionable, and include context that helps developers understand and fix the issue…

Error Handling

Evolve return values

⭐ 112.2K

When extending APIs with new capabilities, carefully consider how changes to return values affect consumers. Avoid cr…

API

Technical documentation precision

⭐ 133K

Ensure technical documentation is precise, accurate, and correctly formatted to prevent confusion and improve develop…

Documentation

Secure Data Handling in Next.js Applications

⭐ 133K

When building Next.js applications that handle sensitive data, it’s crucial to implement robust security measures to …

Next.js

Effective Cache Management in Next.js Applications

⭐ 133K

When implementing caching in Next.js applications, it is crucial to be intentional about the caching behavior for eac…

Next.js

Design domain-specific error types

⭐ 19K

Create and use domain-specific error types instead of generic errors or anyhow. This improves error handling clarity …

Error Handling

Technical precision matters

⭐ 20.8K

When documenting AI models, frameworks, and optimization techniques, precision in language is as important as precisi…

⭐ 30.3K

Always follow the lock-defer-unlock pattern when protecting shared resources with mutexes. Acquire the lock, immediat…

Concurrency

Choose appropriate lock primitives

⭐ 30.3K

Select lock types based on access patterns - prefer RWLock over Mutex for read-heavy operations to enable concurrent …

Concurrency

Documentation clarity and formatting

⭐ 32.9K

Ensure documentation is clear, precise, and consistently formatted. Key practices include:

1. **Be explicit and unam…

Documentation

Use semantic exceptions

⭐ 33.8K

Choose exception types that accurately reflect the nature of the error. Use `LogicException` for developer errors lik…

Error Handling

Precise type annotations

⭐ 33.8K

Always use the most specific and accurate type information possible in PHPDoc comments to improve static analysis, ID…

Documentation

Write clear documentation

⭐ 34K

Documentation should be clear, precise, and self-contained while following established style conventions. When writin…

Documentation

Isolate configuration concerns

⭐ 86.9K

Keep configuration settings separate from application code by using environment variables or dedicated configuration …

Configurations

Document all responses

⭐ 86.9K

When designing APIs, thoroughly document all possible responses your endpoints can return, not just the “happy path” …

API

Single source documentation

⭐ 67.3K

Maintain documentation with a single source of truth to prevent inconsistencies and reduce maintenance burden. When i…

Documentation

Enforce null safety patterns

⭐ 67.3K

Implement comprehensive null safety patterns to prevent runtime errors and ensure predictable behavior. Follow these …

Null Handling

Optimize before implementing

⭐ 73.1K

Before implementing algorithms, evaluate their efficiency implications, especially for operations that may be execute…

Algorithms

Document API completely

⭐ 14K

All public APIs must have comprehensive and clear documentation that helps developers understand functionality withou…

Documentation

Semantic naming patterns

⭐ 33.9K

Names should clearly communicate purpose, relationships, and domain context. Choose identifiers that reveal intent an…

Naming Conventions

Prefer pythonic simplicity

⭐ 33.9K

Use Python’s expressive features to write cleaner, more maintainable code by reducing nesting and improving readabili…

Code Style

Extract and organize methods

⭐ 7.9K

Break down large, complex methods into smaller, focused methods with clear names that describe their purpose. This im…

Code Style

Write pythonic code

⭐ 7.7K

Embrace Python’s idiomatic programming style to make your code more readable, concise, and maintainable. Follow these…

Code Style

Safe dictionary access

⭐ 7.7K

Always use safe dictionary access patterns when handling potentially null or missing values. This prevents KeyError a…

Null Handling

Restrict public network

⭐ 7.7K

Always configure cloud resources to restrict or disable public network access unless explicitly required for the appl…

Networking

Choose optimal algorithms

⭐ 7.7K

Always select appropriate data structures and algorithms based on their performance characteristics and the specific …

Algorithms

Write self-documenting tests

⭐ 9.4K

Tests should clearly communicate their purpose and expectations without requiring readers to analyze implementation d…

Testing

Use descriptive action names

⭐ 40.9K

Names should clearly indicate purpose and behavior using appropriate action verbs and descriptive terms. This applies…

Naming Conventions

Test through public APIs

⭐ 62.1K

Write comprehensive tests that validate functionality through public interfaces rather than testing implementation de…

Testing

Follow logging best practices

⭐ 51.7K

Maintain high-quality logging throughout the codebase by following these best practices:

1. **Use appropriate log le…

Logging

Check before access

⭐ 51.7K

Always verify that objects, attributes, and variables are not None before accessing their properties, calling their m…

Null Handling

Dynamic configuration needs validation

⭐ 19.8K

When implementing dynamic configuration options, validate that the system actually supports runtime changes for that …

Configurations

Descriptive consistent naming

⭐ 74K

Choose variable, function, and class names that accurately reflect their purpose while maintaining consistency with e…

Naming Conventions

Structure for readability

⭐ 60.3K

Organize code to maximize readability and maintainability. When code becomes complex, break it down into smaller, mor…

Code Style

Redact URL credentials

⭐ 60.3K

Always redact sensitive credentials in URLs before logging, displaying in error messages, or serializing to prevent a…

Security

Organize tailwind classes

shadcn-ui/ui

⭐ 90.6K

Structure your Tailwind CSS classes for readability and maintainability. Instead of long chains of conditional classe…

Code Style

Structure conditional compilation

⭐ 29K

Use organized structural patterns for conditional compilation to improve code maintainability and readability. Avoid …

Configurations

Follow naming conventions

⭐ 29K

Choose names that follow established API conventions and guidelines to create a consistent, intuitive codebase:

1. F…

Naming Conventions

Meaningful consistent names

⭐ 190.6K

Choose names that are both semantically precise and follow consistent conventions. Names should accurately reflect be…

Naming Conventions

Use AssertJ correctly

⭐ 58.4K

Spring Framework tests must use AssertJ for assertions rather than JUnit’s `Assertions`, Spring’s `Assert` class, or …

Testing

Maintain consistent naming patterns

⭐ 77.6K

Follow established naming patterns and conventions throughout the codebase to ensure consistency and clarity. This in…

Naming Conventions

Consistent observability data

⭐ 77.6K

When implementing observability features, always ensure consistency in your data model, especially with tags and attr…

Observability

Use data providers effectively

⭐ 1.9K

Organize your test suite by using data providers to consolidate similar test cases rather than creating multiple test…

Testing

Evolve API safely

⭐ 1.9K

When modifying existing APIs, implement changes that maintain backward compatibility while enabling new functionality…

API

Minimize mocks verify behavior

⭐ 41.3K

Write tests that verify actual system behavior rather than implementation details by minimizing mock usage and focusi…

Testing

Simplify code expressions

⭐ 16.6K

Strive for clarity by simplifying code expressions and reducing unnecessary complexity. Complex or verbose expression…

Code Style

Choose error strategies deliberately

⭐ 40.6K

Make deliberate choices about error handling strategies based on the context. Decide between early returns with appro…

Error Handling

Database-specific query optimization

⭐ 57K

Leverage database-specific features to optimize queries and improve performance. Different database engines have uniq…

Database

Configure at proper scope

⭐ 57K

Place configuration options at their proper scope within the framework hierarchy. Avoid tight coupling between compon…

Configurations

Meaningful error communication

⭐ 14.7K

Error handling should be designed to provide clear, actionable information to developers while avoiding redundancy. F…

Error Handling

Document configuration comprehensively

⭐ 14.7K

Configuration properties should be thoroughly documented with explicit details about constraints, units, default valu…

Configurations

API evolution strategy

⭐ 14.7K

Design APIs with future extensibility in mind by using parameter objects instead of direct method parameters. When an…

API

Document code rationale

⭐ 24.4K

Add clear comments that explain the “why” behind non-obvious code decisions, complex logic, or special-case handling….

Documentation

Consistent term capitalization

⭐ 24.4K

Follow consistent capitalization rules for technical terms, acronyms, and library names throughout your codebase and …

Naming Conventions

Meaningful consistent naming

⭐ 11.8K

Use names that clearly describe the purpose and behavior of variables, methods, classes, and files, while maintaining…

Naming Conventions

Specify configuration behaviors

⭐ 25.9K

When implementing configuration features (variables, flags, resources), thoroughly document their behavior in all sce…

Configurations

Optimize code location scope

⭐ 2.1K

Place code in the most specific and appropriate location to improve findability and maintainability. Follow these pri…

Code Style

Future-proof API design

⭐ 2.1K

Design APIs that can evolve without breaking existing code. Use keyword-only arguments (with `*,`) for optional param…

API

Use proper assertions

⭐ 82.9K

Write tests with proper assertions to ensure reliability and maintainability. Follow these guidelines:

1. **Check fo…

Testing

Use optimized functions

⭐ 82.9K

When implementing algorithms, prefer using OpenCV’s built-in optimized functions over writing custom implementations….

Algorithms

Maintain consistent style

⭐ 2.8K

Follow established patterns consistently throughout the codebase to improve readability and maintainability:

1. **Us…

Code Style

Version APIs with care

⭐ 112.2K

When introducing new API features or changes, implement proper versioning to maintain stability and backward compatib…

API

Public over internal APIs

⭐ 112.2K

When designing or implementing APIs, always prefer publicly documented APIs over internal ones. Internal APIs may cha…

API

Benchmark before optimizing code

⭐ 112.2K

Performance optimizations should be validated through benchmarks before implementation. This helps prevent premature …

Performance Optimization

Simplify control flow

⭐ 34.2K

Streamline code by simplifying control flow structures to improve readability. Eliminate unnecessary nesting and verb…

Code Style

Proper asynchronous error handling

⭐ 71.8K

Ensure errors in asynchronous operations and event-based systems are handled consistently to prevent unexpected behav…

Error Handling

Descriptive identifier names

⭐ 71.8K

Choose identifier names (variables, functions, parameters, classes) that clearly describe their purpose, content, or …

Naming Conventions

Structure endpoints for REST

⭐ 19K

Organize API endpoints hierarchically by resource type and use appropriate HTTP methods based on operation semantics….

API

Clear consistent identifier names

⭐ 19K

Choose clear, consistent, and non-redundant names for identifiers across the codebase. Follow these guidelines:

1. U…

Naming Conventions

Simplify for readability

⭐ 20.8K

Complex expressions, especially nested ternary operations, reduce code readability and maintainability. Prefer simple…

Code Style

Consistent naming patterns

⭐ 20.8K

Maintain consistent naming conventions throughout the codebase to enhance readability and reduce confusion. This appl…

Naming Conventions

Modern C++ style practices

⭐ 1.4K

Apply modern C++ features and consistent syntax patterns to improve code readability and safety. Follow these guideli…

Code Style

Surface errors to users

⭐ 13.6K

Always provide user-visible feedback for errors instead of only logging to the console. This ensures users are aware …

Error Handling

Falsy vs null checks

⭐ 13.6K

Distinguish between falsy values (0, ‘’, false, null, undefined) and null/undefined values in your code. Use explicit…

Null Handling

Cache expensive operations

⭐ 13.6K

Identify and cache results of computationally expensive or repetitive operations instead of recalculating them multip…

Performance Optimization

Use comprehensive JSDoc

⭐ 15K

Always use JSDoc format (`/** */`) instead of regular comments (`//`) for documenting classes, functions, and interfa…

Documentation

Preserve API backward compatibility

⭐ 15K

When modifying existing APIs, maintain backward compatibility by implementing changes in a non-breaking way. Use meth…

API

Simplify code structure

⭐ 15.1K

Strive to simplify code structure by eliminating unnecessary complexity. This includes:

1. **Move conditions higher …

Code Style

Follow documentation conventions

⭐ 68.8K

Ensure documentation adheres to established style guidelines and technical standards:

1. **Use proper terminology an…

Documentation

Use modern PHPUnit attributes

⭐ 33.8K

Prefer modern PHPUnit attributes over PHPDoc annotations for improved type safety, IDE support, and code readability …

Testing

Technical term consistency

⭐ 86.9K

When working with multilingual codebases or documentation, maintain consistent naming conventions for technical terms…

Naming Conventions

Sync versus async tests

⭐ 86.9K

Choose the appropriate testing approach based on your test requirements. For standard API endpoint testing, use `Test…

Testing

Standardize dependency version notation

⭐ 67.3K

When specifying dependencies in package.json, follow consistent version notation patterns that align with your projec…

Configurations

Follow StandardJS when modifying

⭐ 67.3K

When modifying existing code, update the touched lines to follow StandardJS conventions while preserving the style of…

Code Style

Clear intention in names

⭐ 67.3K

Choose names that clearly communicate intention and follow established conventions. This applies to variables, functi…

Naming Conventions

Use descriptive identifier names

⭐ 84.2K

Choose clear, descriptive names for variables, functions, and classes that accurately convey their purpose and follow…

Naming Conventions

Document with examples

⭐ 7.9K

Always include comprehensive documentation with clear examples for properties, methods, and code patterns. Documentat…

Documentation

Consistent descriptive naming patterns

⭐ 7.9K

Use clear, descriptive names that follow consistent patterns across the codebase. For methods and properties:

1. Use…

Naming Conventions

Meaningful identifier names

⭐ 7.7K

Choose descriptive and semantic identifiers that clearly convey purpose, role, and behavior. Avoid vague, generic nam…

Naming Conventions

Validate nullability explicitly

⭐ 79.1K

Always validate null or undefined values before using them to prevent crashes and undefined behavior. When implementi…

Null Handling

Assert before cast

⭐ 79.1K

Always validate values before performing unsafe operations like dynamic casting. When a value could be null, zero, or…

Null Handling

Standardize API integration patterns

⭐ 44.2K

Establish consistent patterns for API integrations by following these guidelines:

1. Document API endpoint usage spe…

API

Optimize collection operations

⭐ 44.2K

Use Ruby’s built-in collection methods to write more efficient and readable code. This reduces algorithmic complexity…

Algorithms

Prevent algorithmic pitfalls

⭐ 9.4K

Avoid common algorithmic errors that lead to incorrect results or inefficient code by following these practices:

1. …

Algorithms

Follow naming conventions

Consider algorithmic complexity

⭐ 62.1K

When implementing algorithms, be mindful of their computational complexity and choose appropriate data structures for…

Algorithms

Use self-documenting names

⭐ 51.7K

Variable, function, and parameter names should accurately reflect their purpose, behavior, and content. Choosing desc…

Naming Conventions

Stable documentation links

⭐ 51.7K

Ensure all documentation links are stable, consistent, and correctly targeted to improve navigation and long-term mai…

Documentation

Process configurations consistently

Network API design consistency

⭐ 29K

When designing networking APIs, maintain consistency with existing interfaces while ensuring proper cross-platform co…

Networking

Follow import style

⭐ 29K

Tokio projects follow specific import conventions for consistency and readability. Adhere to these guidelines:

1. Us…

Code Style

Flexible consistent API patterns

⭐ 29K

Design APIs with flexibility and consistency by leveraging established patterns and avoiding unnecessary constraints….

API

Design error handling carefully

⭐ 29K

When implementing error handling, balance between propagation and recovery. Design error types to preserve context wh…

Error Handling

Simplify for readability

huggingface/tokenizers

⭐ 9.9K

Prioritize code readability by using simpler and more direct expressions. When possible, return values directly inste…

Code Style

Descriptive purpose-driven naming

⭐ 45.5K

Choose identifiers that accurately describe their purpose and behavior, not just their type or how they’re used. Name…

Naming Conventions

Contextual null checks

⭐ 45.5K

Use type-appropriate null checking strategies based on the context of your data. For primitive values, ensure they ex…

Null Handling

Choose efficient implementations

⭐ 190.6K

When implementing algorithms, prioritize both correctness and performance by selecting appropriate data structures, o…

Algorithms

Use appropriate collections

⭐ 58.4K

Choose the right collection implementation for each algorithmic task to optimize both performance and readability. Us…

Algorithms

Meaningful exception design

⭐ 77.6K

Design exceptions to provide clear context, preserve stack traces, and propagate correctly through your system. Key p…

Error Handling

Documentation clarity principles

⭐ 77.6K

When writing technical documentation, adhere to these core principles to ensure clarity and effectiveness:

1. **Use …

Documentation

Document configuration properties completely

⭐ 77.6K

Configuration properties should be fully documented with clear descriptions, explicit default values, and proper meta…

Configurations

Concrete bean return types

⭐ 77.6K

When defining `@Bean` methods in Spring configurations, use concrete return types rather than interfaces while using …

Spring

Alphabetical ordering requirement

⭐ 77.6K

Always maintain alphabetical ordering for lists of elements including dependencies, modules, configuration entries, a…

Code Style

Use descriptive identifiers

⭐ 41.3K

Choose variable, parameter, field, and class names that clearly communicate their purpose and context. Favor specific…

Naming Conventions

Structure logs with context

⭐ 41.3K

Use structured logging with appropriate context and log levels to maximize the value of log messages. Include relevan…

Logging

Explicit null handling

⭐ 1.9K

Always be explicit and consistent when handling null values to improve code clarity and prevent subtle bugs. This app…

Null Handling

Feature flag rollouts

⭐ 41.3K

Use feature flags to gate new functionality for controlled rollouts. This allows for quick enabling/disabling without…

Configurations

Optimize common paths

⭐ 16.6K

Design algorithms that optimize for the most common execution paths by prioritizing frequent scenarios in conditional…

Algorithms

Model actual hardware costs

⭐ 16.6K

Base optimization decisions on accurate hardware cost models rather than outdated assumptions. Modern architectures h…

Performance Optimization

Document configuration intent

⭐ 16.6K

Configuration settings should be self-documenting with clear intent. When adding temporary workarounds, conditional f…

Configurations

Handle nulls with Option

⭐ 40.6K

Use Rust’s Option type and its methods effectively to handle nullable values. This improves code clarity and safety b…

Null Handling

Prefer simpler expressions

⭐ 57K

Always choose the simplest, most readable way to express your code logic. Unnecessary complexity makes code harder to…

Code Style

Minimize unnecessary object allocations

⭐ 57K

Avoid creating unnecessary objects, especially in frequently executed code paths. This includes being mindful of impl…

Performance Optimization

Minimize public API surface

⭐ 57K

Design APIs with a minimal public surface area by carefully controlling which methods and properties are exposed. Sta…

API

Follow documentation conventions

⭐ 57K

Maintain consistent formatting and style in all documentation to improve readability and professionalism:

1. **Use p…

Documentation

Document APIs clearly

⭐ 57K

When designing and documenting APIs, prioritize clarity and completeness through concrete examples and accurate param…

API

Thread-safe state management

⭐ 14.7K

When managing state accessed by multiple threads, ensure thread safety through appropriate synchronization mechanisms…

Concurrency

Graceful API evolution

⭐ 91.3K

When modifying, deprecating, or replacing APIs, ensure a smooth transition experience for developers by following the…

API

Standardize dependency management

⭐ 24.4K

Maintain consistent dependency management practices across CI workflows to ensure reliable builds and tests. Use the …

CI/CD

Maintain code consistency

⭐ 24.4K

Ensure code follows consistent patterns throughout the codebase, even when duplicating code is necessary. When simila…

Code Style

Least privilege principle

⭐ 11.8K

Always follow the principle of least privilege by granting the minimum permissions necessary for functionality. This …

Security

Optimize memory allocation patterns

⭐ 34.3K

Minimize memory allocations and optimize allocation patterns to improve performance. Key practices:

1. Pre-allocate …

Performance Optimization

Names reveal clear intent

⭐ 34.3K

Choose names that clearly communicate intent and context, avoiding ambiguity or confusion. Variable and function name…

Naming Conventions

Explicit null handling

⭐ 34.3K

Always be explicit and consistent about how null values are handled in operations and documentation. This clarity pre…

Null Handling

Structure tests thoroughly

⭐ 25.9K

Create well-structured tests with thorough coverage of both expected success and error conditions. Name test cases de…

Testing

Safe lock patterns

⭐ 25.9K

When implementing concurrent operations, ensure locks are acquired and released properly in all execution paths. Alwa…

Concurrency

Reduce code nesting

⭐ 25.9K

Minimize nesting levels and complexity in your code to improve readability and maintainability. Use early returns ins…

Code Style

Write purposeful comments

⭐ 2.1K

Comments should explain “why” and “how” rather than restating what is already obvious from the code. Focus on providi…

Documentation

Sanitize observability data exports

⭐ 2.1K

When exporting observability data (metrics, traces, logs) to external systems, properly sanitize all data fields to e…

Observability

Use OpenCV error mechanisms

⭐ 82.9K

Always use OpenCV’s built-in error handling mechanisms instead of C++ exceptions or custom error handling. This ensur…

Error Handling

Prevent null vulnerabilities

⭐ 82.9K

Use container classes and smart pointers instead of manual memory allocation to prevent null pointer dereferences and…

Null Handling

Cross-platform API design rules

⭐ 82.9K

Design public APIs to work seamlessly across different programming languages and platforms. Follow these key principl…

API

Clear API contracts

⭐ 82.9K

Design APIs with clear contracts that behave exactly as their names and signatures suggest. Functions should do preci…

API

Optimize with standard library

⭐ 145.7K

When implementing algorithms, prefer using Go’s standard library over custom implementations or external dependencies…

Algorithms

Use nullable for optionals

⭐ 2.8K

When a property or parameter represents an optional value that might be absent in requests or responses, use nullable…

Null Handling

Prefer clarity over cleverness

⭐ 112.2K

Write code that prioritizes readability and maintainability over cleverness or excessive optimization. Avoid overly c…

Code Style

Handling Dynamic Content in Next.js Components

⭐ 133K

When implementing Next.js components that rely on dynamic content (e.g. random values, current time), it is crucial t…

Next.js

Use null validation utilities

⭐ 34.2K

Consistently use utility methods like `ObjectUtil.checkNotNull()` or `Objects.requireNonNull()` to validate that para…

Null Handling

Memory ordering needs barriers

⭐ 34.2K

Ensure proper memory ordering in concurrent code by using appropriate memory barriers and atomic operations based on …

Concurrency

Structure behavior-driven tests properly

⭐ 71.8K

Organize tests using behavior-driven development (BDD) patterns to improve clarity and maintainability. Group related…

Testing

Follow protocol standards

⭐ 71.8K

When implementing networking features, strictly adhere to protocol specifications and standards to ensure proper inte…

Networking

Optimize cargo dependencies

⭐ 19K

Maintain clean and efficient dependency configurations in Cargo.toml files by following these practices:

1. **Use wo…

Naming Conventions

Handle errors by severity

⭐ 1.4K

Choose error handling mechanisms based on error severity and recoverability:

1. Use throws for unrecoverable errors …

Error Handling

Consistent API practices

⭐ 1.4K

Maintain consistency in API design, documentation, and implementation across all supported platforms to improve devel…

API

Preserve error handling context

⭐ 13.6K

Always preserve error context by using specific error types, safe error handling patterns, and meaningful error messa…

Error Handling

Maintain naming consistency

⭐ 13.6K

Use consistent and descriptive names for variables, components, and functions throughout the codebase. When the same …

Naming Conventions

Hook and state correctness

⭐ 13.6K

Ensure React hooks and state updates follow best practices to prevent subtle bugs:

1. **Call hooks unconditionally**…

React

Prefer nullish coalescing

⭐ 15K

When handling null or undefined values, use modern JavaScript patterns to write more robust and maintainable code:

1…

Null Handling

Prefer descriptive errors

⭐ 50.9K

When handling errors in your code, always provide detailed context in error messages to aid debugging. Use Kotlin’s s…

Error Handling

Wrap errors with context

⭐ 30.3K

Always wrap errors with meaningful context using fmt.Errorf and %w verb. Include relevant identifiers (filenames, IDs…

Error Handling

Follow API conventions

⭐ 30.3K

Design APIs following modern conventions and best practices to improve usability, maintainability, and consistency ac…

API

Choose optimal data structures

⭐ 30.3K

Select data structures based on specific access patterns and performance requirements. When both fast lookup and pred…

Algorithms

Minimize redundant operations

⭐ 8.3K

Optimize application performance by preventing unnecessary renders, calculations, and network operations. Implement p…

Performance Optimization

Handle nulls with types

⭐ 8.3K

Enforce type safety by properly handling null and undefined values through TypeScript types and explicit checks. Avoi…

Null Handling

Enforce atomic database operations

⭐ 8.3K

Replace check-then-act patterns with atomic database operations to prevent race conditions in concurrent environments…

Concurrency

Explicit null validation

⭐ 68.8K

Always validate objects for null/nil before accessing their properties, and establish consistent patterns for handlin…

Null Handling

Descriptive semantic names

⭐ 68.8K

Always use descriptive variable, parameter, function, and constant names that clearly convey their purpose and behavi…

Naming Conventions

Document code behavior

⭐ 83K

Document the “why” and “how” of your code, not just what it does. Add clear comments to explain:

1. Non-obvious beha…

Documentation

Robust SSH integration

⭐ 32.9K

When implementing SSH integration in your application, follow these practices to ensure reliability across different …

Networking

Document configs comprehensively

⭐ 32.9K

Configuration options must be documented comprehensively with:

1. Clear, descriptive name using appropriate platform…

Configurations

Organize code logically

Use connection by alias

⭐ 84.2K

When working with database operations in Django projects that might use multiple database backends, always access dat…

Database

Validate and document nulls

⭐ 14K

Always handle null values explicitly and consistently throughout your codebase to prevent null pointer exceptions. Fo…

Null Handling

Structure errors with intent

⭐ 33.9K

Implement error handling with clear intent and proper propagation. Follow these principles:

1. Use structured try/ca…

Error Handling

Write comprehensive test cases

⭐ 50.8K

Tests should thoroughly cover all code paths and edge cases. Each test case should: 1. Test distinct scenarios in sep…

Testing

Strict props event handling

⭐ 50.8K

Enforce strict typing and consistent handling of component props and events to ensure type safety, runtime validation…

Vue

Evolve APIs gracefully

⭐ 50.8K

When modifying or extending APIs, prioritize backward compatibility while providing clear migration paths for future …

API

Choose semantic descriptive names

⭐ 50.8K

Names should be clear, descriptive and follow consistent patterns. Choose names that accurately reflect the purpose a…

Naming Conventions

Avoid redundant computations

⭐ 50.8K

Identify and eliminate redundant operations that cause performance bottlenecks by caching expensive function results,…

Performance Optimization

Never commit secrets

⭐ 7.9K

Private cryptographic keys, certificates with private keys, and other secrets must never be committed to source code …

Security

Memoize expensive operations

⭐ 7.9K

Cache results of expensive operations, especially shell commands and external queries, to avoid redundant executions….

Performance Optimization

Keep actions versions current

⭐ 7.9K

Always use the latest stable versions of GitHub Actions components in CI/CD workflows to avoid deprecated features, s…

CI/CD

Externalize configuration values

⭐ 7.9K

Avoid hardcoding configuration values directly in scripts, especially for values that might change between environmen…

Configurations

Choose semantic algorithms

⭐ 7.9K

Select algorithms and data operations that match the semantic intent of your code rather than using convenient but po…

Algorithms

Document configuration consistently

⭐ 7.7K

Ensure all configuration options are clearly documented and follow consistent naming and syntax conventions. This inc…

Configurations

Check exceptions consistently

⭐ 79.1K

Always check for exceptions immediately after operations that might throw them, especially before using the results i…

Error Handling

Minimize unnecessary operations

⭐ 44.2K

Optimize performance by eliminating redundant operations and arranging code to avoid unnecessary computations, especi…

Performance Optimization

Follow established naming patterns

⭐ 44.2K

Names should be descriptive and consistent with existing patterns in the codebase. This applies to methods, variables…

Naming Conventions

Clear error recovery paths

⭐ 44.2K

Implement error handling that provides both clear recovery paths for users and graceful degradation for the system. T…

Error Handling

Clear code examples

⭐ 44.2K

Documentation should include clear, actionable code examples that users can reliably follow. Avoid using ambiguous pl…

Documentation

Comprehensive API documentation

⭐ 9.4K

Always provide comprehensive API documentation that includes accurate examples, complete parameter descriptions, and …

Documentation

Use domain-specific type names

⭐ 5.8K

Types should be named with clear domain context rather than generic terms. Avoid single-word or overly generic names …

Naming Conventions

Minimize memory allocations

⭐ 5.8K

Reduce garbage collection pressure and improve application performance by avoiding unnecessary memory allocations. Th…

Performance Optimization

Document code reasoning

⭐ 5.8K

Add clear, concise comments that explain the “why” behind complex logic, non-obvious decisions, and implicit behavior…

Documentation

Prefer simpler code constructs

⭐ 22.1K

Always opt for simpler, more idiomatic code constructs over complex or verbose alternatives. This includes using buil…

Code Style

Semantic naming conventions

⭐ 7.6K

Use descriptive, semantic names for all code elements that clearly indicate their purpose and behavior. Follow consis…

Naming Conventions

Early return after errors

⭐ 7.6K

When handling errors in asynchronous functions, always return immediately after invoking a callback with an error to …

Error Handling

Document APIs thoroughly

⭐ 7.6K

All public API elements must be thoroughly documented with JSDoc annotations that clearly explain their purpose, para…

Documentation

Validate user-controlled paths

⭐ 40.9K

Always validate and sanitize user-provided inputs used in file path operations to prevent path traversal attacks. Pat…

Security

Standardize API parameter handling

⭐ 40.9K

Use consistent parameter handling patterns across API endpoints to ensure maintainability and predictable behavior. F…

API

Avoid code duplication

⭐ 40.9K

Extract repeated code patterns into reusable functions, variables, or constants to improve maintainability and reduce…

Code Style

Verify AI model capabilities

⭐ 15.6K

Always verify and accurately document AI model capabilities, supported formats, and limitations before implementation…

Type-safe null handling

⭐ 15.6K

Use TypeScript’s type system and modern JavaScript features to prevent null reference errors.

**TypeScript type saf…

Null Handling

Keep tests simple

⭐ 15.6K

Tests should be straightforward, explicit, and free from complex logic or indirection. Avoid “magic” in tests that ma…

Testing

⭐ 51.7K

Mathematical and logical operations require careful validation to ensure correctness. Common issues include:

1. Oper…

Algorithms

Remove unnecessary code elements

⭐ 51.7K

Keep code clean and maintainable by removing unnecessary elements that add complexity without value:

1. Remove unuse…

Code Style

Preserve API compatibility

⭐ 51.7K

When modifying API interfaces, parameters, or argument behavior, ensure backward compatibility is maintained to preve…

API

Optimize memory allocation

⭐ 19.8K

Always allocate data structures with appropriate initial capacity and use memory-efficient data types to reduce memor…

Performance Optimization

Runtime-agnostic API design

⭐ 74K

When designing APIs for systems that support multiple JavaScript runtimes, prioritize decoupling server state from us…

API

Propagate errors with context

⭐ 74K

Always propagate errors with proper context and recovery strategy. Use try-catch blocks for both synchronous and asyn…

Error Handling

Environment variable management

⭐ 74K

When working with environment variables in Vite applications, be explicit about variable loading behavior and precede…

Configurations

Secure configuration defaults

⭐ 60.3K

Establish secure default configurations in project metadata files to prevent accidental publishing and ensure proper …

Configurations

Optimize CI/CD commands

⭐ 60.3K

Design CI/CD workflows to be efficient, consistent, and purposeful across all environments. When writing or modifying…

CI/CD

Environment variable best practices

⭐ 60.3K

When implementing environment variable configuration:

1. Follow standard environment variable conventions: - Use upp…

Configurations

⭐ 45.5K

Organize code to keep related functionality together. When functions serve similar purposes or operate on the same da…

Code Style

Validate quantization parameters carefully

⭐ 190.6K

When implementing quantized operations in ML models, thoroughly validate quantization parameters to ensure correctnes…

Validate before dereference

⭐ 190.6K

Always check that pointers, optional values, and results of type casts are valid before dereferencing or using them. …

Null Handling

Optimize loop operations

⭐ 190.6K

Minimize expensive operations within inner loops to improve performance. Key practices include:

1. Extract loop-inva…

Performance Optimization

Informative error messages

⭐ 190.6K

Error messages should be informative, actionable, and concise to help users quickly understand and fix issues. Follow…

Error Handling

Handle dynamic shapes

⭐ 190.6K

When implementing tensor-based algorithms, avoid assumptions about fixed tensor shapes by not relying on direct shape…

Algorithms

Teach by example

⭐ 6.1K

Present concepts through clear, focused examples that demonstrate features positively rather than through comparisons…

Documentation

Respect annotation processing order

⭐ 58.4K

When designing Spring components, pay careful attention to the order in which annotations are processed, especially f…

Spring

Design for API extension

⭐ 58.4K

When designing APIs, prioritize extensibility by providing clear extension points and avoiding direct exposure of imp…

API

Cleanup error handling

⭐ 58.4K

When handling resources that require cleanup (like streams, connections, or transactions), ensure that errors during …

Error Handling

API boundary null handling

⭐ 58.4K

Establish consistent null handling patterns at API boundaries to prevent null pointer exceptions and improve code cla…

Null Handling

Property description conventions

⭐ 77.6K

When documenting configuration properties in Spring Boot applications, follow these conventions for clarity and consi…

Documentation

Secure sensitive data

⭐ 41.3K

Always protect sensitive data through proper encryption, secure cookies, and careful exception handling to prevent in…

Security

Remove unnecessary code elements

Initialize nil-prone variables

⭐ 57K

Always initialize variables that might be nil to appropriate default values to prevent unexpected behavior. For boole…

Null Handling

Prefer Optional over nulls

⭐ 14.7K

Use Java’s Optional API instead of null checks to improve code readability, safety, and maintainability. When dealing…

Null Handling

Optimize algorithmic operations

⭐ 14.7K

Before implementing or modifying algorithms, carefully evaluate data structure properties and operation costs. Always…

Algorithms

Name for meaning first

⭐ 14.7K

Choose names that prioritize domain meaning and clarity over implementation details. This applies to methods, variabl…

Naming Conventions

Document public APIs

⭐ 14.7K

All public APIs, interfaces, and methods should include comprehensive JavaDoc that clearly explains their purpose, pa…

Documentation

Clear database configuration examples

⭐ 14.7K

Database configuration examples in documentation should be correct, minimal, and include proper context. Provide only…

Database

Use higher-level iterations

⭐ 91.3K

When working with multiple sequences that need to be combined, prefer higher-level iteration abstractions over nested…

Algorithms

Prevent null pollution

⭐ 91.3K

Design your code to minimize the unexpected introduction of None values into data structures and APIs. Use immutable …

Null Handling

Handle errors specifically

⭐ 91.3K

Always be explicit and specific when handling errors rather than using catch-all approaches or implicit conventions. …

Error Handling

Robust error messaging

⭐ 24.4K

Create clear, specific, and actionable error messages that help users understand and resolve issues, while implementi…

Error Handling

Eliminate redundant computation

⭐ 24.4K

Identify and eliminate redundant or duplicate computation paths in your code, especially for expensive operations lik…

Algorithms

Cache expensive computations

⭐ 24.4K

Implement strategic caching and memoization for expensive or frequently repeated computations to avoid redundant work…

Performance Optimization

Secure authentication flows

⭐ 11.8K

Implement authentication flows that protect sensitive information and follow secure credential management practices: …

Security

Safe attribute access patterns

⭐ 11.8K

Implement consistent patterns for safely accessing potentially null or undefined attributes and dictionary values. Th…

Null Handling

Prioritize code readability

⭐ 11.8K

Write code that optimizes for human readability and understanding. Complex expressions, while technically correct, ca…

Code Style

Consistent naming patterns

⭐ 11.8K

Follow systematic naming conventions for types, interfaces, and functions to enhance code readability and navigabilit…

Naming Conventions

Hide implementation details

⭐ 34.3K

Design public APIs to hide implementation details and focus on the user’s mental model of the system. Avoid exposing …

API

Explicit configuration precedence

⭐ 34.3K

Implement a clear configuration resolution chain that follows a consistent precedence pattern: explicit parameters fi…

Configurations

Evaluate algorithmic complexity tradeoffs

⭐ 34.3K

When implementing algorithms, carefully evaluate tradeoffs between performance optimizations and code maintainability…

Algorithms

Document with examples

⭐ 25.9K

Always include clear, contextual examples when documenting APIs, interfaces, or command-line functionality. Examples …

API

Defensive null handling

⭐ 25.9K

Always initialize data structures before use, particularly before accessing them in loops or conditional blocks. Chec…

Null Handling

Clear concise documentation

⭐ 25.9K

Write documentation that is direct, consistent, and appropriately detailed. Follow these principles:

1. **Use direct…

Documentation

⭐ 145.7K

Always check for nil values and successful type assertions before accessing or dereferencing objects, especially when…

Null Handling

Document synchronization intent

⭐ 145.7K

Always clearly document the purpose and scope of synchronization primitives (mutexes, read-write locks) by:

1. Placi…

Concurrency

Comprehensive test coverage

⭐ 145.7K

Test functions should provide comprehensive coverage of both expected and edge cases. Include tests for:

1. **Bounda…

Testing

Clear recoverable error messages

⭐ 145.7K

Error messages should be clear, actionable, and indicate whether recovery is possible. When designing error handling:…

Error Handling

Use descriptive identifiers

⭐ 19K

Choose clear, meaningful names for variables, parameters, and constants that convey their purpose without requiring a…

Naming Conventions

Stage configuration changes gradually

⭐ 19K

When introducing configuration changes that affect multiple system components, implement them in stages to ensure smo…

Configurations

Hierarchical semantic naming

⭐ 19K

Use hierarchical prefixes and clear descriptive names to indicate the domain, source, and purpose of code elements. T…

Naming Conventions

Flexible documented configurations

⭐ 19K

Create configuration interfaces that are flexible, well-documented, and future-proof. When designing configuration pa…

Configurations

⭐ 20.8K

Choose names that clearly reveal the purpose, behavior, or type of the code elements they represent. A good name shou…

Naming Conventions

Hybridization compatible operations

⭐ 20.8K

When implementing neural network models that will be hybridized for performance optimization, use operations that are…

Explain optimization mechanisms

⭐ 20.8K

When implementing or documenting performance optimizations, clearly explain the mechanism and expected performance be…

Performance Optimization

Document all parameters

⭐ 20.8K

Always provide complete and accurate documentation for all function parameters, especially when adding new ones. Each…

Documentation

Configure CSS layers

⭐ 96.1K

When integrating Material UI with other styling solutions like Tailwind CSS v4, proper configuration of CSS layers is…

Configurations

Structure documentation effectively

⭐ 1.4K

Documentation should prioritize clear organization with a logical flow to help developers find information quickly. A…

Documentation

Self-documenting code naming

⭐ 1.4K

Method, parameter, and variable names should clearly describe their purpose and behavior, making code self-documentin…

Naming Conventions

Prefer safe null handling

⭐ 1.4K

Use explicit, safe practices when dealing with potentially null resources to prevent memory leaks and undefined behav…

Null Handling

Document public API completely

⭐ 1.4K

All public APIs (files in `include/`) must have comprehensive documentation using either Doxygen-style or triple-slas…

Documentation

Validate all inputs

⭐ 13.6K

All user-controlled inputs must be validated and sanitized before use to prevent injection attacks, unauthorized acce…

Security

Use structured logging framework

⭐ 13.6K

Replace all console.* calls with an appropriate structured logging framework using proper log levels. This ensures co…

Logging

Memoize computed values

⭐ 13.6K

Cache the results of expensive operations and component renders to avoid redundant calculations during re-renders. Th…

Performance Optimization

Ensure deterministic query results

⭐ 13.6K

Always ensure database queries produce deterministic results by including explicit ORDER BY clauses when using LIMIT …

Database

Avoid array mutations

⭐ 13.6K

Always clone arrays before performing operations that would mutate the original array, especially when working with c…

Code Style

Validate untrusted input

⭐ 15K

Always validate and sanitize user-provided inputs before using them in sensitive contexts like SQL queries, file path…

Security

Throw meaningful errors

⭐ 15K

Always throw specific, actionable errors instead of returning unexpected values or simply logging issues. Error messa…

Error Handling

Optimize model token usage

⭐ 15K

Implement token-efficient patterns when working with AI models to optimize costs and performance. Key practices inclu…

Follow documentation standards

⭐ 15K

Ensure all documentation follows established templates and includes required sections. When referencing components, a…

Documentation

Use modern JavaScript idioms

⭐ 15.1K

Favor modern JavaScript syntax and clean code practices to improve readability and maintainability. This includes:

1…

Code Style

Structured documentation with examples

⭐ 15.1K

Create comprehensive documentation with clear structure and practical examples. Documentation should include:

1. **S…

Documentation

Standardize makefile patterns

⭐ 15.1K

Maintain consistent Makefile patterns across all components to improve build reliability and developer experience in …

CI/CD

Environment variable management

Close resources with errors

⭐ 68.8K

Always close resources (files, streams, connections) and properly handle their Close() errors. For read operations, C…

Error Handling

Use if-unwrap with optionals

⭐ 32.9K

Always use Zig’s if-unwrap pattern (`if (optional) |value| {…}`) when working with optional values instead of force…

Null Handling

Handle errors completely

⭐ 95.9K

Always handle errors comprehensively by checking return values, implementing proper error propagation, and ensuring r…

Error Handling

Connection lifecycle management

⭐ 95.9K

Implement comprehensive lifecycle management for network connections. Ensure proper initialization, authentication, m…

Networking

Manage dependencies wisely

⭐ 33.8K

When configuring dependencies in composer.json files, follow these guidelines to ensure maintainable and reliable con…

Configurations

Escape column names properly

⭐ 33.8K

Always use the appropriate wrapping/escaping mechanism when generating SQL to prevent syntax errors and SQL injection…

Database

Design flexible APIs

⭐ 33.8K

When designing APIs, prioritize flexibility and developer experience by:

1. **Accept broader parameter types** - Use…

API

Type-safe API designs

⭐ 34K

Design APIs with strong type safety to improve developer experience and catch errors at compile time. Avoid using any…

API

Properly Handle Errors in Fastify Applications

⭐ 34K

When implementing error handling in Fastify applications, it is important to always throw instances of the Error clas…

Fastify

Preserve error context

⭐ 34K

When handling errors, always ensure the original error context is preserved and properly surfaced. Error information …

Error Handling

Null safe patterns

⭐ 34K

Use concise null checking patterns to prevent runtime errors and improve code readability when handling potentially u…

Null Handling

Explicit Configuration Usage in Fastify

⭐ 34K

When using the Fastify framework in TypeScript, ensure that all configuration options are explicitly declared and pro…

Fastify

Consistent JSDoc standards

⭐ 34K

Document all public APIs and significant internal functions with comprehensive JSDoc comments that include accurate d…

Documentation

Adhere to Fastify Coding Conventions

⭐ 34K

When implementing code that uses the Fastify package in TypeScript, ensure the following conventions are followed: av…

Fastify

Protocol-specific error handling

⭐ 86.9K

Handle errors and responses appropriately based on the network protocol being used. Different protocols have differen…

Networking

Consistent code examples

⭐ 86.9K

Maintain consistent formatting and styling in code examples throughout your NestJS application documentation. This en…

NestJS

REST principles first

⭐ 67.3K

When designing APIs with Express, prioritize proper REST principles and HTTP semantics over convenience. This ensures…

API

Propagate errors properly

⭐ 67.3K

Always forward errors to the framework’s error handling pipeline instead of swallowing them or handling them inconsis…

Error Handling

Handle streams properly

⭐ 67.3K

When transferring data over HTTP, properly implement streaming mechanisms to prevent memory exhaustion and potential …

Networking

Ensure test completion

⭐ 67.3K

Tests must properly terminate by following appropriate asynchronous patterns. For asynchronous tests, always invoke t…

Testing

Prevent redundant operations

⭐ 73.1K

In distributed database systems, prevent redundant operations that can overload cluster resources. When implementing …

Database

Version annotation in docs

⭐ 84.2K

Always include appropriate version annotations when documenting new features or changes in behavior. Use `.. versiona…

Documentation

Use semantic HTML elements

⭐ 84.2K

Structure HTML templates using semantically appropriate elements rather than generic containers. Replace non-semantic…

Code Style

Structure logs effectively

⭐ 84.2K

When implementing logging in your application, structure your log messages and parameters consistently to improve rea…

Logging

Preserve error handling context

⭐ 84.2K

When handling exceptions, preserve the original error context and provide clear, actionable error messages. This help…

Error Handling

Graceful API evolution

⭐ 84.2K

When evolving APIs, prioritize backward compatibility and provide clear migration paths. For any significant change: …

API

Comments versus docstrings usage

⭐ 84.2K

Choose between comments and docstrings based on the documentation’s purpose and scope. Use docstrings for API-level d…

Documentation

User-friendly documentation examples

⭐ 14K

Documentation should guide users toward best practices through clear examples. Begin with positive patterns before co…

Documentation

Use logging best practices

⭐ 14K

Adopt these logging best practices to ensure consistent, efficient, and meaningful logs:

1. **Use Lombok’s `@Slf4j` …

Logging

Numerical stability practices

⭐ 14K

When implementing machine learning algorithms, ensure numerical correctness and stability by following these practice…

Descriptive error context

⭐ 14K

Error messages should be specific, descriptive, and include context to help with debugging. Avoid generic messages li…

Error Handling

Model-agnostic AI code

⭐ 33.9K

When building applications that interact with AI models, avoid hardcoding model-specific behavior and instead design …

Maintain consistent code style

⭐ 7.7K

Ensure tests thoroughly validate functionality through comprehensive assertions. When writing tests:

1. Assert all r…

Testing

Strategic exception management

⭐ 7.7K

Choose the appropriate error handling strategy based on the context and severity of potential failures. Use exception…

Error Handling

Strategic error handling

Descriptive identifier names

⭐ 79.1K

Choose clear, consistent, and accurate identifiers that precisely reflect behavior and follow established patterns. T…

Naming Conventions

Clean all error paths

⭐ 79.1K

Ensure all error paths properly clean up resources and handle errors appropriately. This includes:

1. Using errdefer…

Error Handling

Simplify complex code blocks

⭐ 44.2K

Break down complex code blocks and expressions into simpler, more readable components. Complex boolean logic, nested …

Code Style

Actions workflow best practices

⭐ 44.2K

Use GitHub Actions native features and follow best practices to create maintainable, secure, and reliable CI workflow…

CI/CD

Write clear examples

⭐ 9.4K

Create comprehensive code examples in documentation that demonstrate common operations and use proper formatting. Use…

Documentation

Consistent method interfaces

⭐ 9.4K

Design APIs with consistent method interfaces across related resources to improve usability and reduce learning curve…

API

Configure proxies with schemes

⭐ 9.4K

When configuring proxies in AWS SDK clients, always include the complete URL scheme in proxy definitions. Match the s…

Networking

Specific exceptions for clarity

⭐ 5.8K

Use specific exception types with meaningful error messages rather than generic exceptions to improve error handling,…

Error Handling

Preserve API compatibility

⭐ 5.8K

When evolving APIs, maintain backward compatibility to prevent breaking changes for existing consumers.

Key approac…

API

Maintain clean code structure

⭐ 5.8K

Keep code clean and well-organized by: 1. Removing unnecessary elements: - Delete commented-out code that is no lo…

Code Style

Centralize configuration values

⭐ 5.8K

Configuration values should be defined once and referenced throughout your project to ensure consistency and simplify…

Configurations

Prefer descriptive over brief

⭐ 22.1K

Choose clear, descriptive names over abbreviated or shortened versions. Names should be self-documenting and follow R…

Naming Conventions

Documentation consistency standards

⭐ 22.1K

Maintain consistent documentation formatting standards across all project files, especially in changelogs, code examp…

Documentation

Consistent axum Usage in TypeScript

⭐ 22.1K

When implementing TypeScript code that uses the axum package, maintain consistent and idiomatic usage: always use low…

Axum

Type-safe API interfaces design

⭐ 107K

Design API interfaces with strong type safety while maintaining excellent developer experience. Prefer explicit types…

API

Standardize null value checks

⭐ 107K

Always use consistent patterns and utility functions for handling null and undefined values. This improves code relia…

Null Handling

Specific test assertions

⭐ 107K

When writing tests, explicitly assert specific conditions and expected values rather than relying on general success/…

Testing

Proxy protocol handling

⭐ 107K

When implementing HTTP clients with proxy support, ensure the connection to the proxy uses the protocol specified in …

Networking

Documentation reflects reality

⭐ 107K

Always ensure documentation accurately represents the actual code behavior and implementation details. Include import…

Documentation

Consistent method behaviors

⭐ 107K

Design API methods with predictable behavior patterns that follow common conventions. Methods that modify objects dir…

API

Complete error handling chain

⭐ 107K

Implement comprehensive error handling throughout the codebase by ensuring all error scenarios are properly caught, t…

Error Handling

Structured test resource management

⭐ 7.6K

Organize tests with proper resource lifecycle management to ensure reliability and maintainability. Create test resou…

Testing

Content integrity verification

⭐ 7.6K

When handling HTTP responses, especially with streaming data, properly verify content integrity and length to prevent…

Networking

Validate nulls explicitly

⭐ 40.9K

Always check for null values before using them, and use Python’s idiomatic patterns to make these checks concise and …

Null Handling

Use system configuration defaults

⭐ 40.9K

Always use the configuration system’s default values instead of hardcoding defaults in the code. This ensures consist…

Configurations

Maintain code consistency

⭐ 40.9K

Ensure consistency throughout the codebase by following established patterns for both UI components and code structur…

Code Style

Internationalize ui text

⭐ 40.9K

All user interface text must be internationalized using the appropriate i18n module instead of hardcoded strings. Thi…

Documentation

Handle exceptions with specificity

⭐ 40.9K

Use specific exception types and avoid masking errors through overly broad exception handling or default values. This…

Error Handling

Documentation best practices

⭐ 40.9K

Documentation should follow established best practices to ensure clarity, consistency, and usefulness:

1. **Use prop…

Documentation

Verify properties before logging

⭐ 15.6K

When logging object properties, always verify that the property names exactly match the actual structure of the objec…

Logging

Maintain API naming consistency

⭐ 15.6K

When working with AI model interfaces and result objects, ensure consistent property naming across related components…

Document API schemas

⭐ 15.6K

Add comprehensive JSDoc comments to all API interfaces, types, and schema definitions. This documentation should:

1….

Documentation

Consistent provider options

⭐ 15.6K

When designing APIs that support multiple providers or service integrations, implement consistent patterns for handli…

API

Protect render loop performance

⭐ 62.1K

Ensure render loop operations stay within frame time budget (typically 16.67ms for 60fps). Avoid expensive computatio…

Performance Optimization

Contextualize don’t panic

⭐ 62.1K

Always provide meaningful context for errors and avoid code that can panic in production. Use `.context()` or `.with_…

Error Handling

Background process blocking operations

⭐ 62.1K

Always move potentially blocking operations to background threads to maintain UI responsiveness. Use appropriate spaw…

Concurrency

Document AI model capabilities

⭐ 51.7K

Provide clear, comprehensive documentation for AI model capabilities, especially for multimodal features and deployme…

Use parameterized queries

⭐ 19.8K

Always use parameterized queries with bind variables instead of string concatenation or formatting when constructing …

Database

Standardize error wrapping patterns

⭐ 19.8K

Use consistent error wrapping patterns to preserve error context and ensure proper error code propagation. Always: 1….

Error Handling

Metric design best practices

1. **Use…

Testing

Consistent documentation formatting

⭐ 45.5K

Maintain consistent style in documentation files to improve readability and professionalism. Specifically:

1. **Comm…

Code Style

Configuration override precedence

⭐ 45.5K

When designing systems with configurations that can be specified at multiple levels (global vs local, environment vs …

Configurations

Clarify test documentation

⭐ 45.5K

Ensure all testing-related documentation is clear, accurate, and user-focused. Use precise terminology when describin…

Testing

Choose appropriate API types

⭐ 45.5K

Select the simplest data types that satisfy requirements when designing API signatures. Avoid using complex types (li…

API

⭐ 58.4K

When working with Spring annotations, follow these guidelines to avoid common issues:

1. **Use interface types for d…

Spring

Minimize lock contention

⭐ 58.4K

When implementing thread-safe code, minimize the scope and duration of locks to reduce contention and improve perform…

Concurrency

Consistent style conventions

⭐ 58.4K

Apply consistent formatting and organization conventions throughout the codebase to enhance readability and maintaina…

Code Style

Explicit security documentation

⭐ 77.6K

Always provide explicit and accurate documentation for security-related configurations, including:

1. Use proper con…

Security

Thread management best practices

⭐ 41.3K

When working with threads or thread pools in concurrent code, follow these practices to improve reliability and debug…

Concurrency

Raise contextual error types

⭐ 41.3K

Always raise specific, contextual exception types instead of generic exceptions. Include relevant error details that …

Error Handling

Precise dependency versioning

⭐ 1.9K

When specifying dependency version constraints in configuration files, be deliberate about minimum versions based on …

Configurations

Include practical examples

⭐ 1.9K

Enhance technical documentation with clear, practical code examples that demonstrate usage. This applies to:

1. Chan…

Documentation

Flexible configuration formats

⭐ 1.9K

Support multiple configuration formats where appropriate (string, callable, object) to accommodate different framewor…

Configurations

Balance CI test coverage

⭐ 1.9K

Configure CI workflows to optimize both comprehensive testing and resource usage. For resource-intensive tests that m…

CI/CD

Optimize React hook patterns

⭐ 41.3K

Design React hooks with performance and maintainability in mind by following these key principles:

1. Minimize useEf…

React

Explicit optional type declarations

⭐ 41.3K

Always explicitly declare optional types in interfaces and function parameters rather than relying on runtime checks …

Null Handling

Structure configuration options

⭐ 16.6K

Design and document configuration options (feature flags, environment variables, conditional compilation) to be clear…

Configurations

Maintain consistent formatting

⭐ 16.6K

Ensure consistent formatting and organization throughout the codebase to improve readability and maintainability. Thi…

Code Style

Decompose complex algorithms

⭐ 16.6K

When implementing algorithms, break down complex methods that handle multiple concerns into smaller, more focused met…

Algorithms

Choose appropriate error mechanisms

⭐ 16.6K

Use the right error handling mechanism for each scenario: exceptions for recoverable situations, assertions only for …

Error Handling

Support configuration extension patterns

⭐ 40.6K

When designing configuration systems, provide both replacement and extension options for list-based settings to give …

Configurations

Maintain focused module structure

⭐ 40.6K

Keep modules focused and well-organized by grouping related functionality together and splitting large files into log…

Code Style

Leverage existing API utilities

⭐ 40.6K

When implementing or consuming APIs, always prefer using existing utility methods and abstractions over manual implem…

API

Optimize hot paths

⭐ 237K

In performance-critical code paths that execute frequently, optimize to reduce unnecessary operations that can impact…

Performance Optimization

Balance constraints with flexibility

⭐ 237K

When designing APIs, carefully evaluate constraints imposed on consumers. Each limitation should serve a clear purpos…

API

Understand query method behavior

⭐ 57K

When working with database queries in Active Record, it’s essential to understand the precise behavior of query metho…

Database

Optimize cache headers

⭐ 57K

Use appropriate HTTP cache headers based on content mutability. For immutable assets (like digest-stamped files), app…

Caching

Human-readable configuration values

⭐ 57K

When writing configuration files, prioritize human readability and maintainability by using descriptive expressions i…

Configurations

Efficient data processing

⭐ 57K

When implementing algorithms that process large data streams or collections, use a chunking approach rather than proc…

Algorithms

Contextual error messages

⭐ 57K

Error messages should provide sufficient context to understand and debug the problem efficiently. Include both the ex…

Error Handling

Content security policy configuration

⭐ 57K

Implement Content Security Policy (CSP) configurations appropriately for your application’s context. Use report-only …

Security

Validate database connections explicitly

⭐ 14.7K

Always implement explicit database connection validation strategies to ensure robust application behavior during star…

Database

Secure authentication defaults

⭐ 14.7K

Configure authentication mechanisms with secure default settings to prevent security vulnerabilities. When implementi…

Security

Documentation style consistency

⭐ 14.7K

Maintain consistent documentation style to improve readability and user experience:

1. **Use precise terminology**: …

Documentation

Service layer abstraction

⭐ 11.8K

Separate business logic and external service interactions from API views by using dedicated service layers. This impr…

API

Parameterize security commands

⭐ 11.8K

When writing security-related CLI commands or remediation steps, always use standardized parameter placeholders (e.g….

Security

Memory usage optimization

⭐ 11.8K

Optimize memory usage in high-performance applications by implementing explicit memory management techniques. This in…

Performance Optimization

Maintain component consistency

⭐ 11.8K

Use a consistent approach when working with components to improve code maintainability and ensure visual coherence th…

Code Style

Ensure migration compatibility

⭐ 11.8K

When modifying database schemas through migrations, ensure compatibility with existing data. For new required fields,…

Migrations

Document configuration variables

⭐ 11.8K

Always provide complete documentation for configuration variables, including their exact format, purpose, and behavio…

Configurations

Document authentication requirements

⭐ 11.8K

When creating or modifying APIs, always provide comprehensive documentation for authentication methods and prerequisi…

API

Prevent deadlock conditions

⭐ 34.3K

Carefully manage resource acquisition and release to prevent deadlocks in concurrent code. Deadlocks typically occur …

Concurrency

Prevent cryptic errors

⭐ 34.3K

Always implement proper validation and type checking to prevent cryptic error messages. When errors do occur, provide…

Error Handling

Organize tests efficiently

⭐ 34.3K

Write maintainable, well-structured tests that are easy to understand and extend. Tests should remain simple and focu…

Testing

Optimize data transformations

⭐ 34.3K

When implementing data processing operations, avoid unnecessary data transformations, copies, and conversions that ca…

Database

Design for operation flexibility

⭐ 34.3K

When implementing algorithms that operate on data structures (particularly arrays, lists, or collections), design the…

Algorithms

Defer expensive operations

⭐ 34.3K

Avoid triggering expensive computations prematurely in your code. Operations like `collect()`, intensive IO operation…

Performance Optimization

Choose appropriate abstractions

⭐ 34.3K

When designing APIs, select data types and patterns that match how they will be consumed while facilitating long-term…

API

Proper span lifecycle

⭐ 25.9K

Always ensure trace spans are properly closed in all code execution paths to prevent trace leaks that can distort obs…

Observability

Prevent backing array surprises

⭐ 25.9K

When modifying slices in Go, be aware that appending to a slice with available capacity will modify the backing array…

Algorithms

Minimize API surface

⭐ 25.9K

Design APIs with minimal exposed surface by encapsulating implementation details within packages. When designing APIs…

API

Write reliable test cases

⭐ 2.1K

Create deterministic and reliable test cases by following these guidelines:

1. Use hardcoded values instead of rando…

Testing

Return collections not None

⭐ 2.1K

Return empty collections (lists, dicts, sets) instead of None when representing empty states. This reduces null check…

Null Handling

Prevent recursive logging calls

⭐ 2.1K

Avoid implementing logging calls that could trigger recursive logging patterns, which can lead to infinite loops and …

Logging

Precise configuration specifications

⭐ 2.1K

Ensure configuration files use tool-specific syntax and conventions while leveraging appropriate defaults. Be intenti…

Configurations

Place attributes correctly

⭐ 2.1K

When implementing observability with OpenTelemetry, place attributes at the appropriate level in the telemetry hierar…

Observability

Pin dependency versions

⭐ 2.1K

Always use exact version pinning (==) for dependencies in requirements files rather than version ranges. This ensures…

Configurations

Choose data structures wisely

⭐ 2.1K

Select data structures based on your specific access patterns and performance requirements. Using the right data stru…

Algorithms

Optimize for common cases

⭐ 82.9K

When implementing algorithms, create specialized versions for common cases to improve performance, while maintaining …

Algorithms

Framework synchronization practices

⭐ 82.9K

When implementing concurrent code, always use the framework’s provided synchronization primitives rather than direct …

Concurrency

Document properly with references

⭐ 82.9K

Always separate code from documentation and use proper referencing techniques. Documentation should be in markdown fi…

Documentation

Reuse buffers strategically

⭐ 145.7K

For frequently called methods or hot code paths, reuse allocations instead of creating new buffers on each call. This…

Performance Optimization

Platform-aware configuration documentation

⭐ 145.7K

Always document platform-specific configuration differences and requirements thoroughly. When writing documentation o…

Configurations

Loose API coupling

⭐ 145.7K

Maintain a clear separation between API definitions and their implementations by avoiding direct passing of API struc…

API

⭐ 112.2K

Function and method names should precisely describe their purpose and behavior. Choose names that explicitly communic…

Naming Conventions

Await all promises

⭐ 112.2K

Always explicitly await all asynchronous operations, especially in cleanup code paths and resource management. Failin…

Concurrency

Verify documentation references

⭐ 133K

When writing or updating documentation, ensure all code examples, installation commands, and project references accur…

Documentation

Proper Use of Suspense in Next.js Components

⭐ 133K

When building Next.js applications that leverage server-side rendering (SSR) or Partial Prerendering (PPR), it is ess…

Next.js

Proper Error Handling in Next.js API Routes

⭐ 133K

This review focuses on ensuring proper error handling in Next.js API routes. Key principles include validating incomi…

Next.js

Maintain Consistent Naming Conventions in Next.js Code

⭐ 133K

As a code reviewer for Next.js projects, ensure that all code artifacts, including component names, file names, and c…

Next.js

Protect network buffer lifecycle

⭐ 34.2K

When handling network buffers in protocol implementations, ensure proper lifecycle management to prevent memory leaks…

Networking

Preserve backward compatibility

⭐ 34.2K

When evolving APIs in minor versions, always maintain backward compatibility to avoid breaking client code. Follow th…

API

Optimize search operations

⭐ 34.2K

Enhance search algorithm performance by prioritizing common cases, using appropriate data structures, and avoiding un…

Algorithms

Configurable over hardcoded

⭐ 34.2K

Make configuration parameters configurable rather than hardcoding values, especially for limits, sizes, and threshold…

Configurations

Use consistent control structures

⭐ 71.8K

Always use curly braces for control structures (if, for, while, etc.), even for single-line statements. This improves…

Code Style

Structure exception handling patterns

⭐ 71.8K

Implement consistent exception handling using framework-provided mechanisms rather than ad-hoc try-catch blocks or ma…

Error Handling

Standardize logger configuration patterns

⭐ 71.8K

Maintain consistent logger configuration and usage patterns across the application while leveraging built-in customiz…

Logging

Prevent async race conditions

⭐ 71.8K

Design async operations to prevent race conditions, memory leaks, and ensure proper resource cleanup. Key principles:…

Concurrency

Pin dependency versions

⭐ 71.8K

Explicitly pin or constrain dependency versions in CI/CD configurations instead of using `latest` tags. This prevents…

CI/CD

Package dependency configuration

⭐ 71.8K

Configure dependencies appropriately in package.json based on usage patterns and requirements. This improves package …

Configurations

HTTP header management

⭐ 1.4K

Always establish and maintain clear ownership semantics in concurrent code to prevent data races. This includes:

1. …

Concurrency

Document platform requirements

⭐ 1.4K

When setting or changing minimum platform version requirements, always document the specific technical reasons for th…

Configurations

Descriptive named constants

⭐ 1.4K

Replace magic numbers and unclear variables with descriptive named constants using appropriate naming conventions. Th…

Naming Conventions

Configure platform-specific builds

⭐ 1.4K

Ensure build and distribution configurations are properly documented and optimized for each target platform. For cros…

Configurations

Prevent flaky test timing

⭐ 13.6K

Replace non-deterministic timing patterns with reliable alternatives to prevent flaky tests. This includes:

1. Use e…

Testing

Pin dependency versions

⭐ 13.6K

Always pin external dependencies to specific versions in CI/CD workflows to ensure build reproducibility, stability, …

CI/CD

Explicit null value checks

⭐ 13.6K

Use explicit null/undefined checks instead of truthy/falsy checks when handling potentially null or undefined values….

Null Handling

Configuration value consistency

⭐ 13.6K

Maintain consistency in configuration values across the application by following these practices:

1. **Use properly …

Configurations

Use database-native types

⭐ 15K

Always leverage database-native data types and appropriate schema design to maximize performance and query capabiliti…

Database

Eliminate redundant code

⭐ 15K

Simplify code by eliminating redundancy and unnecessary complexity. This improves readability, reduces potential bugs…

Code Style

Dependency classification standards

⭐ 15K

Properly classify dependencies in package.json according to their usage pattern and project guidelines. This ensures …

Configurations

Avoid flaky test patterns

⭐ 30.3K

Write reliable tests by avoiding common patterns that can lead to flaky behavior. Specifically:

1. Avoid arbitrary t…

Testing

Test all code paths

⭐ 8.3K

Write comprehensive tests that cover all code paths including edge cases, error conditions, and different parameter c…

Testing

Prevent workflow recursion

⭐ 8.3K

Control GitHub Actions workflow execution to avoid infinite loops and unnecessary builds. Implement these practices: …

CI/CD

Normalize API responses

⭐ 8.3K

Design APIs to return consistent response structures across different data sources or providers. Normalize responses …

API

Handle AI operation failures

⭐ 8.3K

Always implement proper error handling for AI service operations. AI services can fail due to rate limiting, network …

Ensure API contract integrity

⭐ 8.3K

Maintain strict consistency between API implementation and contract by ensuring: 1. Request/response schemas match ex…

API

Define schema relations correctly

Name for purpose first

⭐ 68.8K

Choose names that lead with their primary purpose or category, followed by specific details. This makes code more dis…

Naming Conventions

Minimize database joins

⭐ 68.8K

Prefer direct filtering or specialized service methods over complex JOIN operations, especially when maintaining or r…

Database

Maintain configuration documentation accuracy

⭐ 68.8K

Always ensure configuration documentation accurately reflects the current system capabilities, limitations, and featu…

Configurations

Judicious configuration management

⭐ 83K

Implement consistent error handling patterns throughout your codebase to improve readability and maintainability.

**…

Error Handling

Structure user documentation

⭐ 32.9K

When documenting complex features or configuration options, structure your documentation with these four key elements…

Documentation

⭐ 33.8K

Configuration keys should clearly indicate their value type, units, or expected format to prevent misunderstandings a…

Configurations

Proper Handling of Promises in Fastify Implementations

⭐ 34K

When implementing Fastify applications in TypeScript, it is important to follow consistent patterns for handling prom…

Fastify

Content negotiation design

⭐ 34K

When building APIs, implement proper content negotiation to handle various media types in both requests and responses…

API

Consistent descriptive naming

⭐ 34K

Use precise, consistent, and descriptive naming conventions throughout your code to enhance readability and maintaina…

Naming Conventions

Benchmark before choosing methods

⭐ 34K

Always benchmark different implementation approaches for performance-critical operations before selecting a method. D…

Performance Optimization

Use pytest fixtures effectively

⭐ 86.9K

Tests should use pytest fixtures to improve organization, promote test isolation, and avoid code duplication. Fixture…

Testing

Use early returns

⭐ 86.9K

Decrease indentation levels in your code by using early returns for edge cases and guard conditions. This approach im…

Code Style

Respect async execution order

⭐ 86.9K

When working with asynchronous code, always be mindful of the execution order of operations, particularly with regard…

Concurrency

Proper HTTP status codes

⭐ 86.9K

When implementing authentication and authorization systems, use semantically correct HTTP status codes to accurately …

Security

Optimize hot paths

⭐ 67.3K

When writing code that will be executed frequently (hot paths), prioritize performance optimizations that reduce over…

Performance Optimization

Optimize dependency automation

⭐ 67.3K

Configure automated dependency update tools (like Dependabot) to balance security needs against developer cognitive l…

Configurations

Access settings properly

⭐ 67.3K

Always use the provided settings accessor methods (`app.get()`, `app.set()`, `app.enabled()`, `app.disabled()`) to ac…

Configurations

Parallel branch traceability

⭐ 73.1K

When implementing algorithms with parallel processing branches, ensure proper traceability and data consistency acros…

Algorithms

Exceptions for critical errors

⭐ 73.1K

Use exceptions rather than assertions for handling critical error conditions that need to be caught in production. As…

Error Handling

Defensive null handling

⭐ 73.1K

Always handle null references and values defensively to prevent NullPointerExceptions and unexpected behavior. Follow…

Null Handling

Configure type serialization

⭐ 73.1K

When working with databases that exchange data with other systems, ensure proper serialization and deserialization of…

Database

Clarity over uncertainty

⭐ 73.1K

Technical documentation should use precise language that clearly differentiates between product behavior and user con…

Documentation

Prevent N+1 queries

⭐ 84.2K

The N+1 query problem is one of the most common performance bottlenecks in Django applications. This occurs when you …

Database

Optimize computational complexity

⭐ 84.2K

Identify and reduce computational complexity in your code by minimizing redundant operations and simplifying algorith…

Algorithms

Measure before optimizing

⭐ 84.2K

Always measure performance impact before implementing optimizations and focus on changes with meaningful benefits. Py…

Performance Optimization

Defend against nulls

⭐ 84.2K

Always use defensive programming techniques when handling potentially null or empty values to avoid runtime errors. C…

Null Handling

Use modern API methods

⭐ 14K

When implementing algorithms with numerical libraries like ND4J, always prefer the most direct and type-safe API meth…

Algorithms

Minimize object allocations

⭐ 14K

Avoid creating unnecessary temporary objects or arrays which can impact performance through increased garbage collect…

Performance Optimization

Keep configurations current

⭐ 14K

Ensure all configuration elements (dependencies, build settings, preprocessor flags) are up-to-date, documented, and …

Configurations

Fail fast clearly

⭐ 14K

Detect and report errors as early as possible with detailed context to prevent silent failures and aid debugging. Val…

Error Handling

Document AI APIs completely

⭐ 14K

When developing AI libraries and tools, provide comprehensive and accurate API documentation that helps users navigat…

Cross-platform algorithm optimization

⭐ 14K

When implementing algorithms that need to execute efficiently across different platforms, consider both compile-time …

Algorithms

Configurable resource locations

⭐ 14K

Always make file paths, temporary directories, and resource locations configurable with reasonable defaults instead o…

Configurations

Compare floating-point safely

⭐ 14K

When implementing numerical algorithms, never compare floating-point values directly for equality due to precision er…

Algorithms

Default None not empty

⭐ 33.9K

Always use `None` as the default value for optional parameters and class attributes instead of empty collections (`[]…

Null Handling

Pause tracking during side-effects

⭐ 50.8K

When executing side-effects in reactive systems (like event handlers, cleanup functions, or async operations), always…

Concurrency

Optimize common search paths

⭐ 50.8K

Implement dedicated fast paths for common search patterns while maintaining a complete fallback path for edge cases. …

Algorithms

Guarantee cleanup execution

⭐ 50.8K

When implementing features that require cleanup or state restoration, always use try-finally blocks to ensure cleanup…

Error Handling

Use strict test doubles

⭐ 7.9K

Always use strict test doubles (instance_double, class_double) instead of basic doubles or OpenStruct in tests. Stric…

Testing

Standardize installation directory paths

⭐ 7.9K

Maintain consistent and separate installation paths for different build types to prevent conflicts and improve system…

Configurations

Secure network operations

⭐ 7.9K

When performing network operations, prioritize security and configurability to ensure robustness across different env…

Networking

Document configuration decisions

⭐ 7.9K

Add clear comments explaining the rationale behind configuration decisions, especially for workarounds, compatibility…

Configurations

Document configuration completely

⭐ 7.9K

Always provide complete documentation for configuration options, including defaults, override methods, and security i…

Configurations

Use pytest best practices

⭐ 7.7K

Adopt modern pytest features to create maintainable, isolated, and comprehensive tests. This includes:

1. **Prefer p…

Testing

Preserve API compatibility

⭐ 7.7K

When modifying existing APIs, function signatures, or return structures, always maintain backward compatibility to pr…

API

Precise configuration validation

⭐ 7.7K

Ensure configuration validation logic accurately reflects security intentions and best practices. When writing valida…

Configurations

Use consistent test patterns

⭐ 79.1K

Standardize testing by leveraging established patterns and helper functions throughout your test suite. Extract repet…

Testing

Consistent descriptive identifiers

⭐ 79.1K

Use camelCase for all variables, parameters, methods, and functions in JavaScript/TypeScript code to maintain consist…

Naming Conventions

Clear accurate documentation

⭐ 79.1K

Documentation should be both technically accurate and contextually helpful for developers. Comments and JSDoc entries…

Documentation

Always await promises

⭐ 79.1K

Consistently use the `await` keyword when working with Promise-returning functions to ensure proper execution flow an…

Concurrency

Structured environment configuration

⭐ 44.2K

Use structured environment variable handling with explicit validation instead of directly accessing ENV hash. Impleme…

Configurations

Correct GitHub Actions annotations

⭐ 44.2K

When using GitHub Actions workflow commands for annotations, always include double colons in the syntax (::command::)…

CI/CD

Avoid variable name abbreviations

⭐ 44.2K

Use complete, descriptive variable names instead of abbreviations to enhance code readability and maintainability. Sh…

Naming Conventions

Structure for readability

⭐ 9.4K

Prioritize code readability by structuring code in a way that makes it easy to understand at a glance. This includes:…

Code Style

Isolate concurrent resources

⭐ 9.4K

Create separate instances of non-thread-safe resources for each thread or process in concurrent applications rather t…

Concurrency

Consistent region configuration

⭐ 9.4K

Always maintain consistency in region configurations throughout your application. Instead of hardcoding endpoints, us…

Configurations

Write deterministic tests

⭐ 5.8K

Tests should be deterministic, reliable, and isolated from external dependencies to ensure consistent results across …

Testing

User-friendly configuration values

⭐ 5.8K

Prefer intuitive, user-friendly values for configuration options over technical “magic strings” or codes that require…

Configurations

Standardize environment variables

⭐ 5.8K

Ensure environment variable names are consistently spelled, properly referenced, and follow established naming conven…

Configurations

Externalize configuration values

⭐ 5.8K

Store configuration values (URLs, demands, pool names) in centralized variables rather than hardcoding them inline. T…

Configurations

Use Option combinators

⭐ 22.1K

Instead of verbose conditional logic, prefer Rust’s Option combinators like map, and_then, and filter for handling po…

Null Handling

Structure errors for safety

⭐ 22.1K

Create specific error types with appropriate status codes while ensuring sensitive details are logged but not exposed…

Error Handling

Minimize memory allocation overhead

⭐ 22.1K

Optimize performance by minimizing unnecessary memory allocations and using allocation-efficient APIs. Key practices …

Performance Optimization

Lock carefully in async

⭐ 22.1K

When using locks in async code, follow critical guidelines to avoid deadlocks. Never hold std::sync::Mutex locks acro…

Concurrency

Handle protocol headers properly

⭐ 22.1K

When implementing network services, especially proxies and protocol handlers, proper HTTP header management is critic…

Networking

Validate security-critical inputs

⭐ 107K

Always validate and sanitize user-supplied inputs before using them in security-sensitive operations. This helps prev…

Security

Robust Axios Usage in TypeScript

⭐ 107K

This review focuses on ensuring robust and type-safe usage of the Axios library in TypeScript codebases. Key recommen…

Axios

Proper Error Handling in Axios TypeScript Code

⭐ 107K

As a code reviewer, it is important to ensure that Axios-based TypeScript code properly handles and propagates errors…

Axios

Extract for better readability

⭐ 107K

Complex expressions and repeated code should be extracted into well-named variables to improve readability and mainta…

Code Style

Maintain consistent formatting

Self-explanatory identifier names

⭐ 62.1K

Choose identifier names that clearly convey their purpose without requiring users to understand implementation detail…

Naming Conventions

⭐ 62.1K

Organize configuration settings hierarchically by grouping related settings under meaningful namespaces rather than c…

Configurations

Secure before deployment

⭐ 51.7K

Remove or secure development-specific code before deploying to production environments. Development artifacts like de…

Security

Protect shared state

⭐ 51.7K

When mutable state (like dictionaries, lists, or counters) is accessed from multiple threads or concurrent tasks, use…

Concurrency

Structured configuration management

⭐ 19.8K

Avoid using global configuration singletons that rely on string-based lookups, as they lead to brittle code that’s ha…

Configurations

Robust network handling

⭐ 19.8K

Always implement proper network timeout handling and address formatting to ensure robust connectivity across differen…

Networking

Secure workflow permissions

⭐ 74K

Define explicit and minimal permissions in GitHub Actions workflows to ensure proper operation while maintaining secu…

CI/CD

Restrict server access

⭐ 74K

Always configure server security settings with explicit allowed lists rather than permissive values. Using `true` for…

Security

Short-circuit evaluation strategies

⭐ 60.3K

When implementing search or traversal algorithms, use short-circuit evaluation strategically to avoid unnecessary com…

Algorithms

⭐ 29K

When writing code that requires unsafe operations, follow these critical security practices:

1. Minimize the scope o…

Security

Clear command documentation

⭐ 29K

When documenting shell commands in technical documentation, use the `shell` language identifier instead of `bash` as …

Documentation

huggingface/tokenizers

⭐ 9.9K

When sharing mutable data between threads, use the `Arc>` pattern to ensure thread safety. `Arc` provides t…

Concurrency

⭐ 6.1K

When implementing generic algorithms in Swift, follow these best practices to improve code clarity and performance:

…

Algorithms

Format for readability

⭐ 6.1K

Code should be formatted to optimize readability. Apply these key practices:

1. **Maintain reasonable line length** …

Code Style

Follow Swift naming conventions

⭐ 6.1K

Ensure code follows established Swift naming conventions and remains consistent with domain terminology:

1. Use stan…

Naming Conventions

Document API stability

⭐ 6.1K

When working with AI frameworks and machine learning libraries, clearly document the stability state of APIs being us…

Standardize configuration formats

⭐ 58.4K

Use consistent, explicit, and well-documented formats in all configuration files to improve readability and prevent m…

Configurations

Package null-safety annotations

⭐ 58.4K

All package-info.java files must include both @NonNullApi and @NonNullFields annotations to establish null-safety at …

Null Handling

Optimize CI environment configuration

⭐ 58.4K

When configuring CI environments, carefully evaluate whether default dependency versions are sufficient for your proj…

CI/CD

Leverage Kotlin null-safety

⭐ 58.4K

Utilize Kotlin’s null-safety features effectively to create cleaner, more robust code:

1. For class properties that …

Null Handling

Database-agnostic SQL syntax

⭐ 58.4K

Write SQL statements that conform to standard SQL rather than relying on vendor-specific dialects to ensure portabili…

Database

Clone network headers carefully

⭐ 58.4K

When working with HTTP or WebSocket headers in networking code, be cautious about header manipulation, cloning, and l…

Networking

Validate nulls properly

⭐ 77.6K

Always use appropriate null validation mechanisms to prevent NullPointerExceptions and ensure code robustness.

For s…

Null Handling

Reference existing configurations

⭐ 77.6K

When setting up configuration files, reference existing configuration sources rather than duplicating values or logic…

Configurations

⭐ 41.3K

Design API endpoints with consistent, unambiguous URL patterns to improve usability and maintainability. Follow these…

API

Clear consistent naming patterns

⭐ 41.3K

Use clear, consistent naming patterns for variables and event handlers. Avoid abbreviations unless they are widely un…

Naming Conventions

Centralize AI code

⭐ 41.3K

Move AI-specific functionality (especially prompts) to dedicated services rather than scattering them throughout the …

API parameter design flexibility

⭐ 41.3K

Design API parameters to be extensible and future-proof by using object arguments and explicit type definitions inste…

API

Algorithm structure optimization

⭐ 41.3K

Optimize algorithm structure by separating concerns and using appropriate data structures and language features. When…

Algorithms

Validate before access

⭐ 16.6K

Always validate parameters and initialize variables before access to prevent null dereference and undefined behavior….

Null Handling

Preserve pointer authentication

⭐ 16.6K

When implementing Pointer Authentication (PAC) for security, maintain signed pointers throughout their entire lifecyc…

Security

Platform-agnostic network APIs

⭐ 16.6K

When implementing networking functionality, ensure code uses platform-agnostic APIs and appropriate abstraction layer…

Networking

Parameterize configuration values

⭐ 16.6K

Extract hard-coded configuration values into variables, parameters, or templates to improve reusability and simplify …

Configurations

Optimize build dependency chains

⭐ 16.6K

When configuring build and test processes in CI/CD pipelines, ensure proper dependency chains with clear inputs and o…

CI/CD

Memory ordering matters

⭐ 16.6K

When working with shared data in multithreaded environments, memory ordering is critical to prevent race conditions a…

Concurrency

Choose descriptive names

⭐ 16.6K

Names should clearly convey purpose and meaning. Parameter, variable, and method names should be self-explanatory and…

Naming Conventions

Verify union attribute access

⭐ 40.6K

When working with union types in Python, always verify that all components of the union have the attributes you’re tr…

Null Handling

Structure documentation effectively

⭐ 40.6K

Documentation should follow a consistent structure where explanations precede code examples, preferably ending with a…

Documentation

Ensure algorithmic determinism

⭐ 40.6K

When implementing algorithms for code analysis, type checking, or pattern matching, ensure they produce consistent an…

Algorithms

Assert exact expectations

⭐ 40.6K

Always assert exact expected values in tests rather than using loose assertions. When testing the presence of element…

Testing

Verify performance empirically

⭐ 237K

Always validate performance optimizations through measurement rather than assumptions. Run multiple iterations of per…

Performance Optimization

Use appropriate testing methods

⭐ 237K

When writing tests, use the appropriate testing utilities and ensure proper test isolation. For testing warning behav…

Testing

Separate conditional paths

⭐ 237K

When working with concurrent operations, separate conditional logic from potentially expensive or suspenseful executi…

Concurrency

Optimize React Component Dependencies

⭐ 237K

When implementing React components, ensure that dependencies between component state, props, and side effects are acc…

React

Match errors to context

⭐ 237K

Choose error handling mechanisms based on the error’s severity and context. For critical issues that should prevent f…

Error Handling

Complete hook dependencies

⭐ 237K

Always specify complete dependency arrays in React hooks to prevent bugs from stale closures and avoid unnecessary re…

React

Check property existence first

⭐ 237K

Always verify that an object and its properties exist before accessing them to prevent ‘cannot read property of undef…

Null Handling

Wrap threaded code properly

⭐ 57K

When working with threads in Rails applications, always wrap application code with `Rails.application.executor.wrap` …

Concurrency

Semantic HTML usage

⭐ 57K

Use HTML elements according to their semantic purpose to ensure proper accessibility and code organization. Choose el…

Code Style

Environment-specific logger configuration

⭐ 57K

Configure loggers in environment-specific files rather than in application.rb or initializers. Different environments…

Logging

Document performance implications

⭐ 57K

Clearly document the performance implications of features and configurations to help users make informed decisions. A…

Performance Optimization

Consistent terminology usage

⭐ 57K

Always use consistent terminology for the same concept throughout your codebase, documentation, and user interfaces. …

Naming Conventions

Reuse test patterns

⭐ 14.7K

Minimize duplication and improve test maintainability by reusing existing test patterns and leveraging parameterizati…

Testing

Document deployment strategy constraints

⭐ 14.7K

Always document and enforce appropriate deployment strategies for different application types in your CI/CD pipeline …

CI/CD

Document dependency versions

⭐ 14.7K

When managing dependency versions in configuration files, provide clear documentation to help maintainers understand …

Configurations

Descriptive consistent naming

⭐ 14.7K

Use clear, descriptive names instead of cryptic abbreviations, and follow consistent naming patterns across your code…

Naming Conventions

Avoid request-path blocking

⭐ 14.7K

Minimize blocking operations in request-handling paths to ensure responsive application performance. Implement cachin…

Performance Optimization

Thread context management

⭐ 91.3K

Always explicitly set required thread context and state rather than assuming inheritance from parent threads or other…

Concurrency

Structure for readability

⭐ 91.3K

Structure code to maximize readability by reducing unnecessary complexity. Use early returns to minimize nesting leve…

Code Style

Reusable workflow design

⭐ 91.3K

Design CI/CD workflows with reusability and clear naming conventions from the start. Use meaningful prefixes that ref…

CI/CD

Reduce code duplication

⭐ 91.3K

Eliminate repeated code patterns by using appropriate abstraction techniques. This improves readability, reduces main…

Code Style

Purpose-revealing identifier names

⭐ 91.3K

Choose identifier names that clearly reveal their purpose and behavior. Names should be specific, descriptive, and se…

Naming Conventions

Prefer HINTS in CMake

⭐ 91.3K

When configuring library searches in CMake, use `HINTS` instead of `PATHS` when you want to prioritize specific locat…

Configurations

Parameterize similar test cases

⭐ 91.3K

Instead of duplicating test code or using nested loops, use test parameterization to handle multiple test cases effic…

Testing

Modular configuration design

⭐ 91.3K

Configuration systems should be designed with modularity and clarity in mind. When creating configuration classes or …

Configurations

Document configuration decisions

⭐ 91.3K

Always document configuration decisions in package metadata files like `pyproject.toml` with clear comments, especial…

Configurations

Consistent code organization

⭐ 34.3K

Maintain consistent and standardized naming throughout the codebase:

1. **Use snake_case for multi-word identifiers*…

Naming Conventions

CI workflow configuration best

Maintain consistent naming

⭐ 2.1K

Ensure naming conventions are consistent across your codebase and related repositories. When naming commands, functio…

Naming Conventions

Explicit CI configurations

⭐ 2.1K

Always use explicit, specific configurations in CI/CD pipelines to prevent ambiguity and conflicts. This includes:

1…

⭐ 112.2K

When dealing with potentially null or undefined values, use optional chaining (`?.`) and nullish coalescing (`??`) op…

Null Handling

Use appropriate metric types

⭐ 112.2K

When instrumenting applications with metrics, choose the correct metric type based on what you’re measuring to ensure…

Observability

Reuse computed values efficiently

⭐ 112.2K

Move variable declarations and computations outside of loops when their values don’t change between iterations. This …

Performance Optimization

Resource-aware programming patterns

⭐ 112.2K

When optimizing application performance, be mindful of system resource constraints and use appropriate patterns to ha…

Performance Optimization

Export environment variables once

⭐ 112.2K

When writing shell scripts, set and export all environment variables at the top of the script rather than modifying t…

Configurations

Write concise idiomatic code

⭐ 133K

Favor concise and idiomatic expressions in your Rust code to improve readability and maintainability.

Code Style

Verify workflow configuration integrity

⭐ 133K

Carefully review GitHub Actions workflow configurations to prevent subtle errors that can cause CI/CD pipeline failur…

CI/CD

Prefer Existence Checks in Next.js Components

⭐ 133K

When working with props, state, or other values in Next.js components that may be null, undefined, or contain error s…

Next.js

Optimize data structure selection

⭐ 133K

Choose data structures that match your specific access patterns and performance requirements. The right data structur…

Performance Optimization

Consistent variable style patterns

⭐ 133K

Maintain consistent patterns for variable declarations and naming conventions: use const by default for variable decl…

Code Style

Prevent test resource leaks

⭐ 34.2K

Always ensure proper cleanup of resources in tests to prevent memory leaks. When using EmbeddedChannel, call readOutb…

Testing

Consistent dependency declarations

⭐ 34.2K

Ensure dependency declarations in build configuration files use concrete values rather than variables that may not re…

Configurations

Use topological sorting

⭐ 71.8K

When managing dependencies between modules or components, implement a topological sorting algorithm to ensure correct…

Algorithms

Use factory providers

⭐ 71.8K

Prefer `useFactory` over `useValue` for better performance in NestJS dependency injection, especially for large objec…

NestJS

Prevent race conditions

⭐ 71.8K

When handling concurrent operations in asynchronous environments, avoid mutating shared state that could lead to race…

Concurrency

Parameterize version requirements

⭐ 71.8K

Always parameterize tool and runtime versions in CI/CD configurations rather than hardcoding them. This makes your pi…

CI/CD

Optimize critical path iterations

⭐ 71.8K

Use appropriate iteration techniques in performance-critical code paths to minimize overhead and maximize execution s…

Performance Optimization

Graph-based dependency management

⭐ 71.8K

When managing module dependencies in a system, treat the dependencies as a directed graph and apply appropriate graph…

Algorithms

Secure authentication handling

⭐ 19K

Always implement proper authentication checks and protect sensitive credentials throughout your codebase. This includ…

Security

Precise algorithm terminology

⭐ 19K

When implementing and documenting algorithms, use precise terminology and be explicit about metrics, operations, and …

Algorithms

Performance test pragmatism

⭐ 19K

When designing performance tests, focus on efficiency and meaningful insights rather than exhaustive combinations. Co…

Performance Optimization

Optimize data structures

⭐ 19K

When implementing algorithms, prioritize data structure choices that minimize resource usage while maintaining functi…

Algorithms

Handle all error paths

⭐ 19K

Ensure comprehensive error handling throughout the codebase by implementing proper error handling blocks, defensive v…

Error Handling

Guard against race conditions

⭐ 19K

When working with concurrent operations, always implement proper guards to prevent race conditions between processes….

Concurrency

Extract and reuse

⭐ 19K

Create focused utility functions for repeated or complex operations instead of duplicating logic across the codebase….

Code Style

Environment-specific config defaults

⭐ 19K

Define appropriate configuration defaults for different environments (development, testing, production) using dedicat…

Configurations

Document API specs completely

⭐ 19K

When designing and implementing APIs, always provide comprehensive specifications that clearly document all endpoints…

API

Database before memory

⭐ 19K

When working with database systems that also maintain in-memory state, always update the persistent database state be…

Database

Configuration context alignment

⭐ 19K

Choose the appropriate configuration context based on how changes will be handled by the system. When defining custom…

Configurations

Configurable cache parameters

⭐ 19K

Cache configurations should be runtime-configurable rather than hardcoded, with support for dynamic resizing when con…

Caching

Cache performance preservation

⭐ 19K

When implementing database failover or restart mechanisms, ensure performance consistency by preserving and prewarmin…

Database

Avoid flaky tests

⭐ 19K

Tests should be designed to be deterministic and reliable to prevent wasted developer time and false confidence.

Tw…

Testing

⭐ 20.8K

When implementing concurrent operations, especially in heterogeneous computing environments (CPU/GPU), centralize syn…

Concurrency

Centralize configuration parameters

⭐ 20.8K

Avoid hardcoded paths and duplicated configuration values throughout the code. Instead:

1. Use dedicated configurati…

Configurations

Use design system tokens

⭐ 96.1K

Always use design system tokens (theme values, breakpoints, spacing units) instead of hard-coded values. This ensures…

Code Style

Maintain configuration accuracy

⭐ 96.1K

Regularly audit configuration files to remove unused entries and ensure all configurations accurately reflect the pro…

Configurations

Explicit configuration resolution

⭐ 96.1K

Always use explicit path resolution and document ordering requirements in configuration files to prevent environment-…

Configurations

Effect hook best practices

⭐ 1.4K

When designing classes and interfaces, prefer passing lightweight objects by value rather than using raw pointers or …

Null Handling

⭐ 1.4K

Design APIs by organizing related properties into purpose-specific structures rather than flat parameter lists. This …

API

Externalize configuration values

⭐ 1.4K

Use environment variables and external configuration mechanisms instead of hard-coding values in build scripts. This …

Configurations

Externalize config values

⭐ 1.4K

Replace hardcoded “magic numbers” and environment-specific logic with externally configurable values. Use preprocesso…

Configurations

DRY class hierarchies

⭐ 1.4K

Follow the Don’t Repeat Yourself (DRY) principle when designing class hierarchies. Extract common functionality into …

Code Style

Design evolution-ready APIs

⭐ 1.4K

Design APIs that are both explicit in their usage and provide clear evolution paths. When designing APIs:

1. Prefer …

API

Cross-platform CI validation

⭐ 1.4K

Always verify that code changes work across all CI platforms before submitting. When addressing a CI issue for one pl…

CI/CD

Validate environment variables strictly

⭐ 13.6K

Implement comprehensive validation for environment variables using a schema validation library (e.g., Zod). Include p…

Configurations

Standardize configuration values

⭐ 13.6K

Maintain consistent naming patterns across all database objects. Ensure that:

1. Related object names are aligned (e…

Naming Conventions

Documentation completeness check

⭐ 15K

Ensure all documentation is complete, well-formatted, and maximally useful for developers. This includes:

1. **Use p…

Documentation

Constructor over setter

⭐ 15K

Prefer passing configuration through constructor parameters rather than setting properties after instantiation. This …

API

Consistent naming conventions

⭐ 15K

Maintain consistent and explicit naming conventions across your codebase that reflect:

1. **Component dependencies**…

Naming Conventions

⭐ 15.1K

Design configurations that work consistently across different environments without requiring environment-specific mod…

Configurations

Document with precision

⭐ 8.3K

Understand and correctly implement the asynchronous behavior of Next.js APIs and components. Follow these guidelines:…

Guard against null chains

⭐ 8.3K

Prevent null pointer exceptions by validating object chains before accessing nested properties. Use early returns wit…

Null Handling

Externalize configuration values

⭐ 8.3K

Configuration files should not contain hardcoded values for usernames, credentials, hostnames, or environment-specifi…

Configurations

Database type best practices

⭐ 8.3K

Select appropriate data types and defaults for database columns to ensure data integrity and simplify application cod…

Database

Proper mocking techniques

⭐ 68.8K

Use appropriate mocking approaches for different dependencies in tests to ensure accurate test results and prevent fa…

Testing

Optimize hot paths

⭐ 68.8K

Identify and optimize frequently executed code paths by moving invariant calculations and conditional logic outside o…

Algorithms

Measure before optimizing

⭐ 68.8K

Performance optimizations should be validated with measurements rather than assumptions. When implementing performanc…

Performance Optimization

Maintain API version compatibility

⭐ 68.8K

When implementing or modifying APIs, ensure backward compatibility across versions and client interfaces. Carefully e…

API

Graceful feature availability

⭐ 68.8K

When implementing configurable features, ensure they degrade gracefully based on environment conditions like feature …

Configurations

Feature toggle lifecycle

⭐ 68.8K

When working with feature toggles and configuration flags, manage their entire lifecycle carefully to prevent breakin…

Configurations

Design token value consistency

⭐ 68.8K

When implementing design tokens in code, ensure values accurately represent the intended visual outcome, even if desi…

Code Style

Complete configuration fields

⭐ 68.8K

Ensure all plugin configuration files include the complete set of required fields specific to their plugin type. Miss…

Configurations

Write resilient tests

⭐ 83K

Tests should be designed to validate behavior without being brittle or sensitive to implementation details. Avoid dir…

Testing

Use standard API constants

⭐ 83K

Always use standard library constants for HTTP methods and status codes rather than string literals or numeric values…

API

Precompute over recalculate

⭐ 83K

Perform expensive calculations during initialization rather than on each request, and avoid unnecessary operations in…

Performance Optimization

Early return pattern

⭐ 83K

Prefer returning early from functions rather than nesting conditions. When a condition can lead to an early exit, han…

Code Style

Configuration file precision

⭐ 83K

Ensure configuration files are precisely maintained with correct syntax and compatible version declarations. This inc…

Configurations

Prefer safe optional handling

⭐ 32.9K

Always use Swift’s built-in mechanisms for safely handling optional values instead of force unwrapping or manual nil …

Null Handling

Encapsulate implementation details

⭐ 32.9K

When designing APIs, create appropriate abstractions that hide platform-specific or low-level implementation details …

API

Define explicit error sets

⭐ 32.9K

Always define explicit error sets for functions that can fail, rather than using inferred error sets. This makes erro…

Error Handling

Centralize configuration values

⭐ 32.9K

Hardcoded configuration values scattered throughout codebases create maintenance burdens and increase the risk of inc…

Configurations

Centralize configuration management

⭐ 32.9K

Avoid hardcoded or duplicated configuration values by centralizing them in a dedicated location. When configurations …

Configurations

Consistent Fastify Integration Patterns

⭐ 34K

When implementing integrations and plugins using the Fastify framework, maintain consistent coding patterns and conve…

Fastify

⭐ 73.1K

When designing and implementing configuration options, carefully consider two key aspects:

1. **Choose appropriate c…

Configurations

Design for evolution

⭐ 73.1K

When designing APIs, prioritize flexibility and independent evolution of components. Avoid tightly coupling related s…

API

⭐ 84.2K

When implementing HTML templates, add clear comments documenting accessibility-related decisions. Explain the purpose…

Documentation

Clear AI component interfaces

⭐ 33.9K

When designing AI components and tools, use domain-specific terminology and provide clear interface documentation to …

Vue component type safety

⭐ 50.8K

When defining Vue components with TypeScript, use appropriate component definition patterns to ensure proper type inf…

Vue

Use environment flags consistently

⭐ 50.8K

Feature flags like `__DEV__` and `__COMPAT__` are critical configuration mechanisms that control environment-specific…

Configurations

Lifecycle effects management

⭐ 50.8K

Properly manage component lifecycle effects and cleanup in React components to prevent memory leaks and performance i…

React

Standardize shell flags

⭐ 7.9K

Always use `set -eou pipefail` at the beginning of shell scripts to ensure consistent error handling and behavior acr…

Code Style

Remove commented code

⭐ 7.9K

Avoid leaving commented-out code in the codebase. Version control systems already track the history of changes, makin…

Code Style

Fail fast principle

⭐ 7.9K

Design CI/CD pipelines to fail quickly and visibly rather than masking errors through excessive retries or complex co…

CI/CD

Clear abstraction boundaries

⭐ 7.9K

Design APIs with clear and consistent abstraction boundaries to maintain code quality and prevent interface leakage b…

API

Validate configurations correctly

⭐ 7.7K

When writing validation logic for configurations, ensure you’re using the appropriate operators that correctly test f…

Configurations

Support all target environments

⭐ 7.7K

When managing dependency configurations (Pipfiles, requirements.txt, lock files), ensure compatibility with all suppo…

Configurations

Comprehensive security scanning

⭐ 7.7K

Always configure security scanning tools with comprehensive coverage and readable output to maximize vulnerability de…

Security

Backward compatible parameters

⭐ 7.7K

When evolving API function signatures, maintain backward compatibility by making new parameters optional with sensibl…

API

Verify assertions properly

Document non-obvious decisions

⭐ 44.2K

Always add clear comments explaining non-obvious code decisions such as magic numbers, arbitrary values, truncation l…

Documentation

Document CI pipeline comprehensively

⭐ 44.2K

Ensure CI/CD pipeline documentation accurately reflects the complete workflow, including job dependencies, execution …

CI/CD

Manage test environments

⭐ 9.4K

When writing tests that interact with environment variables or configuration settings, always (1) preserve the origin…

Configurations

Demonstrate canonical API patterns

⭐ 9.4K

Always provide examples that demonstrate the recommended and most current API usage patterns. This includes:

1. Usin…

API

Consistent naming standards

⭐ 9.4K

Follow standard Python naming conventions consistently throughout code and documentation. Use underscores instead of …

Naming Conventions

Avoid hidden performance costs

⭐ 9.4K

When designing APIs that interact with remote services, be cautious about implementing convenience features that may …

Performance Optimization

Surface errors appropriately

⭐ 5.8K

Ensure errors are visible and properly handled rather than silently processed or hidden. Provide mechanisms for devel…

Error Handling

Prefer identity-based authentication

⭐ 5.8K

Always prioritize modern identity-based authentication methods over traditional username/password credentials. This i…

Security

Follow formatting standards

⭐ 5.8K

Maintain consistent code formatting by adhering to the defined standards in the .editorconfig file and Azure SDK impl…

Code Style

Descriptive consistent identifiers

⭐ 5.8K

Use clear, descriptive identifiers that accurately reflect their purpose, and maintain consistent naming patterns thr…

Naming Conventions

Centralize pipeline configurations

⭐ 5.8K

Use centralized templates and variables for pipeline configurations instead of duplicating or hardcoding values. This…

CI/CD

Document feature flags

⭐ 22.1K

When configuring feature flags in Cargo.toml, ensure they are properly structured and documented. Chain feature depen…

Configurations

Proper Axios Configuration and Usage

⭐ 107K

When implementing code that uses the Axios library in TypeScript, it is important to follow best practices for config…

Axios

Consistent Naming Conventions for Axios Requests and Responses

⭐ 107K

When using the Axios library in TypeScript, it is important to follow consistent naming conventions to improve code r…

Axios

Configuration property standards

⭐ 107K

Always define configuration properties with sensible defaults and consistent naming conventions. When adding new conf…

Configurations

Validate configurations with clarity

⭐ 7.6K

Configuration validation should use explicit checks and clear conditional logic to improve code readability and preve…

Configurations

Test configuration precedence

⭐ 7.6K

When implementing systems that load configuration from multiple sources, always test the precedence rules explicitly …

Configurations

Limit cache size

⭐ 7.6K

Always implement size constraints on caches to prevent memory leaks and performance degradation. Unbounded caches can…

Caching

Follow established testing patterns

⭐ 7.6K

When writing tests, use existing patterns and infrastructure already established in the codebase rather than creating…

Testing

Explicit verified configurations

⭐ 7.6K

Always specify configuration values explicitly and verify their accuracy against official documentation or tests. Thi…

Configurations

Document APIs completely

⭐ 7.6K

Always provide complete, clear, and contextually rich documentation for all public APIs. Documentation should:

1. Us…

Documentation

Follow naming conventions

⭐ 40.9K

Use proper naming conventions to make code more readable and maintainable:

1. **Functions should start with verbs** …

Naming Conventions

Enforce authentication boundaries

⭐ 40.9K

Implement strict authentication boundaries and access controls to prevent security vulnerabilities:

1. When multiple…

Security

Document intentional choices

⭐ 40.9K

Add explanatory comments for non-obvious code decisions that might appear incorrect, unusual, or suboptimal to future…

Documentation

Validate pattern matching

⭐ 15.6K

When implementing algorithms that involve pattern matching or data parsing, ensure robustness across all edge cases a…

Algorithms

Test before documenting

⭐ 15.6K

Always thoroughly test API features and endpoints before documenting them, especially when integrating with third-par…

API

Provide actionable examples

⭐ 15.6K

Documentation should include concrete, executable code examples rather than vague instructions. Make your examples co…

Documentation

Document configuration decisions

⭐ 15.6K

When modifying configuration files (package.json, tsconfig.json, etc.), document the reasoning behind significant cha…

Configurations

Async error callbacks

⭐ 15.6K

When handling asynchronous operations, especially those that might continue running in the background after the main …

Error Handling

Proper documentation linking

⭐ 62.1K

Documentation should use appropriate linking strategies to ensure content remains accessible and navigable across all…

Documentation

Precise test pattern matching

⭐ 62.1K

When identifying test patterns in code, use specific equality predicates (`#eq?`) instead of list inclusion predicate…

Testing

Minimize credential exposure lifetime

⭐ 62.1K

Credentials and secrets should never be stored persistently in memory or written to files. Instead, use ephemeral pat…

Security

Explicit over implicit

⭐ 62.1K

When designing APIs, prioritize explicit parameter identification over implicit context. APIs with clear, unambiguous…

API

Document configuration clearly

⭐ 62.1K

When adding or modifying configuration parameters, especially in JSON settings files, ensure they are clearly documen…

Code Style

Optimize tensor memory operations

⭐ 51.7K

When working with PyTorch tensors, use memory-efficient operations that avoid unnecessary copies. Specify memory form…

Pytorch

Optimize GPU execution

⭐ 51.7K

Ensure GPU code is optimized for both proper thread utilization and correct architecture dispatching:

1. **Maximize …

Performance Optimization

Match reference names

⭐ 51.7K

Ensure that filenames and paths referenced in scripts, commands, or configuration files exactly match the actual name…

Naming Conventions

Environment-aware configuration values

⭐ 51.7K

When creating configuration files or defining configuration constants, ensure they properly adapt to different enviro…

Configurations

Combine identical CSS

⭐ 51.7K

When multiple CSS selectors share identical styling properties, combine them using comma separation rather than dupli…

Code Style

⭐ 19.8K

When implementing or modifying database-related configurations, follow these principles:

1. Use semantically appropr…

Database

Consistent database APIs

⭐ 19.8K

Design database APIs with consistent patterns for response structures and error handling. Follow established conventi…

Database

Clear metric documentation

⭐ 60.3K

When setting Rust build configurations, especially in CI/Docker environments, explicitly document optimization choice…

Configurations

⭐ 9.9K

Ensure CI/CD workflow configuration files follow best practices for maintainability and correctness:

1. Use centrali…

Configurations

⭐ 190.6K

Always use current assertion methods in test code to ensure clarity and future compatibility. Specifically, replace d…

Testing

Secure infrastructure maintenance

⭐ 190.6K

Maintain CI/CD infrastructure with security and currency as top priorities. This includes:

1. **Keep build tools upd…

CI/CD

Parameterize ci/cd scripts

⭐ 190.6K

Avoid duplicating CI/CD scripts by leveraging configuration files and parameterization instead of creating multiple s…

CI/CD

Framework migration instructions

⭐ 190.6K

When documenting AI framework migrations (like TensorFlow/Keras version changes), provide complete instructions cover…

Format lines and comments

⭐ 190.6K

Ensure all code follows formatting guidelines for readability and consistency. Keep lines under 80 characters, splitt…

Code Style

Document non-obvious code

⭐ 190.6K

Add clarifying comments to improve code readability and maintainability when code behavior isn’t immediately obvious….

Documentation

Consistent variable naming

⭐ 190.6K

Use ALL_CAPS for constants and environment variables in shell scripts, and reference these variables consistently thr…

Naming Conventions

Build dependency synchronization

⭐ 190.6K

When adding new imports to code files, always synchronize by updating the corresponding dependencies in BUILD files. …

Configurations

Be explicit in references

⭐ 190.6K

When writing documentation, always be specific and explicit when referring to files, tools, configurations, or other …

Documentation

Swift style consistency

⭐ 6.1K

Maintain consistent Swift style conventions throughout all code, including examples in documentation and comments. Fo…

Code Style

Minimize cross-device transfers

⭐ 6.1K

Data transfers between different compute devices (CPU/host to GPU/accelerator and back) can significantly impact perf…

Performance Optimization

Follow Swift conventions

⭐ 6.1K

When designing and documenting APIs in Swift, adhere to Swift’s established naming conventions and documentation prac…

API

Verify operation semantics

⭐ 58.4K

When implementing algorithms that process collections or use conditional logic, always verify the exact semantics of …

Algorithms

Use documentation features properly

⭐ 58.4K

Utilize Asciidoc features correctly when writing or updating Spring Framework documentation. Instead of hardcoded lin…

Documentation

Structured log message quality

⭐ 77.6K

Design log messages to be clear, concise, and properly structured to maximize their utility for debugging and monitor…

Logging

Stable observability components

⭐ 77.6K

Always use stable, production-ready versions of observability components (libraries, dependencies, and documentation …

Observability

Include database-specific migration dependencies

⭐ 77.6K

When implementing database migrations with tools like Flyway, ensure you include the appropriate database-specific de…

Migrations

Environment variables best practices

⭐ 77.6K

When working with environment variables in configuration files, follow these practices to ensure reliability and test…

Configurations

Consistent terminology usage

⭐ 77.6K

When referring to technical concepts in documentation and code comments, use proper full names and consistent termino…

Naming Conventions

Clear structured logging documentation

⭐ 77.6K

Document structured logging implementations with clarity, explicitly noting precedence rules and interactions with ot…

Logging

Bean lifecycle management

⭐ 77.6K

When using containers and external services in Spring applications (especially with Testcontainers), declare them as …

Spring

Use acks_late for reliability

⭐ 41.3K

Configure Celery tasks with `acks_late=True` when task reliability is critical and you prefer to risk duplicate proce…

Celery

Reduce code nesting

⭐ 41.3K

Excessive indentation makes code harder to read and understand. Two common techniques can help flatten your code stru…

Code Style

Keep testing dependencies current

⭐ 1.9K

Regularly update testing framework dependencies (PHPUnit, PHPStan, etc.) to maintain compatibility with your project’…

Testing

Ensure test isolation

⭐ 1.9K

Tests should be independent and isolated from each other to prevent state leakage and ensure reliable results. When t…

Testing

Dynamic error configuration

⭐ 1.9K

Design error handling systems that respect runtime changes to error settings rather than fixing configurations at ini…

Error Handling

Document configuration comprehensively

⭐ 1.9K

When adding or modifying configuration options, ensure they are documented with complete context. Group related chang…

Configurations

Optimize lookup operations

⭐ 41.3K

Choose appropriate data structures to minimize computational complexity when performing lookups. Prefer direct lookup…

Algorithms

Migration model imports

⭐ 41.3K

When writing Django migrations, avoid importing and referencing external models directly. Django migrations use auto-…

Migrations

Meaningful test design

⭐ 41.3K

Write tests that focus on unique edge cases and avoid redundancy. When designing test suites:

1. Consolidate similar…

Testing

Use utility macros

⭐ 16.6K

Use predefined utility macros for common operations instead of repeating manual calculations throughout your code. Th…

Code Style

Platform-aware algorithm optimization

⭐ 16.6K

When implementing performance-critical algorithms, design your code to detect and utilize platform-specific hardware …

Algorithms

Optimize aligned SIMD operations

⭐ 16.6K

Always use proper memory alignment for SIMD (Single Instruction, Multiple Data) operations to maximize performance. W…

Performance Optimization

Names reflect actual purpose

⭐ 16.6K

Name variables, properties, and functions to accurately reflect their purpose and actual usage in code, not just thei…

Naming Conventions

Memory barrier pairing

⭐ 16.6K

When implementing low-level synchronization mechanisms in multi-threaded code, ensure that memory barriers are correc…

Concurrency

Maintain configuration compatibility

⭐ 16.6K

When modifying configuration systems, prioritize backward compatibility unless there’s an explicit breaking change pl…

Configurations

Honor API contracts

⭐ 16.6K

When implementing or modifying APIs, carefully preserve the historical behavior and semantic contracts of existing in…

API

Feature flag implementation

⭐ 16.6K

When implementing feature flags, ensure consistency between runtime and compiled scenarios. Feature switches marked w…

Configurations

Explicit API versioning

⭐ 16.6K

When extending interfaces with new methods or functionality, always implement proper versioning to ensure compatibili…

API

Enable configurable instrumentation

⭐ 16.6K

Always provide configurable options for performance instrumentation and hardware acceleration in your codebase. These…

Performance Optimization

Document non-obvious logic

⭐ 16.6K

Add clear comments explaining the purpose and reasoning behind complex or non-obvious code logic. Comments should exp…

Documentation

Document function contracts

⭐ 16.6K

Always document function contracts completely, even when surrounding code lacks documentation. Include header comment…

Documentation

Centralize platform configurations

⭐ 16.6K

Platform-specific code and API usage should be centralized in designated configuration files rather than scattered th…

Configurations

Test edge cases

⭐ 40.6K

When writing tests, prioritize coverage of edge cases and non-standard code patterns to ensure robust functionality. …

Testing

Single yield algorithm

⭐ 40.6K

Context managers must follow a crucial algorithmic constraint: each execution path must yield exactly once. Multiple …

Algorithms

Logical content organization

⭐ 40.6K

Organize code and documentation logically based on functionality and dependencies. Place files in directories that re…

Code Style

Clear and relevant comments

⭐ 40.6K

Ensure all comments in the codebase provide value and clarity rather than creating confusion. Remove comments that ar…

Code Style

Write readable conditionals

⭐ 237K

Structure conditionals for maximum clarity and comprehension. Avoid unnecessary negation in boolean expressions, use …

Code Style

Standardize URL handling

⭐ 237K

When working with URLs in networking code, always use the standard `URL` constructor to properly resolve relative URL…

Networking

Proper Usage of React Hooks

⭐ 237K

When using the React library in TypeScript, ensure that you are correctly implementing the recommended React hooks ba…

React

Proper Scoping and Usage of React Variables

⭐ 237K

When implementing React components, it is important to ensure that variables are properly scoped and used throughout …

React

Multi-stack config settings

⭐ 237K

When creating configuration files for development environments that use multiple technology stacks, ensure settings a…

Configurations

Explicit CSP nonce management

⭐ 237K

When implementing Content Security Policy (CSP) protections, always explicitly pass nonce values to components rather…

Security

Dry configuration patterns

⭐ 237K

Apply DRY (Don’t Repeat Yourself) principles to all configuration files to improve maintainability. Extract shared co…

Configurations

Document code intent

⭐ 237K

Add clear comments that explain the intent and behavior of code that might not be immediately obvious to other develo…

Documentation

Defensive Handling of Nullable React Components

⭐ 237K

When working with React components that may return null or undefined values, implement defensive coding patterns to p…

React

Test helpers for maintainability

⭐ 57K

Create reusable helper methods for common testing operations to improve test maintainability and consistency. Design …

Testing

Spring DI precedence rules

⭐ 14.7K

When developing Quarkus extensions that interact with classes containing Spring annotations (like `@Service`, `@Compo…

Spring

Prevent metrics cardinality explosion

⭐ 14.7K

When implementing metrics and telemetry in your application, avoid using dynamic values like path parameters or user …

Observability

Optimize elimination paths

⭐ 14.7K

When implementing algorithms that process large data structures or complex computational paths, prioritize opportunit…

Algorithms

Keep configurations current

⭐ 14.7K

Always use the latest stable and supported versions in configuration files. This applies to runtime environments, bui…

Configurations

Document observability context flows

⭐ 14.7K

When implementing observability features like OpenTelemetry exporters, metrics collection, or distributed tracing, cl…

Observability

Design fluent HTTP APIs

⭐ 14.7K

When designing HTTP-related APIs, prioritize readability and intuitiveness through well-crafted fluent interfaces. AP…

API

Consolidate duplicate configurations

⭐ 14.7K

Maintain a single source of truth for configuration files instead of duplicating them across the codebase. Duplicated…

Configurations

Type-appropriate null representation

⭐ 91.3K

Always use type-appropriate mechanisms to represent the absence of a value. For objects, use default constructors rat…

Null Handling

Reuse existing algorithms

⭐ 91.3K

Before implementing common algorithms or utilities, check if the codebase already contains an appropriate implementat…

Algorithms

Preserve API compatibility

⭐ 91.3K

When modifying existing APIs, always prioritize backward compatibility to avoid breaking client code. Before changing…

API

Optimize container operations

⭐ 91.3K

Minimize CPU overhead in container operations by using efficient data structure patterns:

1. **Use static containers…

Performance Optimization

⭐ 11.8K

When chaining Celery tasks, choose the correct signature method: - Use `.s()` when a task needs the output from the p…

Celery

⭐ 11.8K

When documenting AI systems, always format code identifiers, function names, agent names, model names, and other tech…

Flexible AI model versions

⭐ 11.8K

When integrating LLM or AI models into your application, implement model selection in a way that accommodates the rap…

Environment variables for configurations

⭐ 11.8K

Store all configurable values such as URLs, API endpoints, and external service locations in environment variables ra…

Configurations

Endpoints for evolving data

⭐ 11.8K

Design dedicated API endpoints for data that changes frequently or grows over time, rather than hardcoding such infor…

API

Enable database resilience

⭐ 11.8K

Always configure appropriate resilience features for database services to ensure data durability and high availabilit…

Database

Consistent environment variable naming

⭐ 11.8K

When naming environment variables, ensure that names are both technically accurate and follow established project con…

Naming Conventions

Configure observability variables

⭐ 11.8K

Always define all necessary environment variables for observability tools in configuration files, even if using defau…

Observability

Use consistent temporal types

⭐ 34.3K

When implementing or modifying temporal operations, maintain consistent data types that align with existing temporal …

Temporal

Edge case algorithm handling

⭐ 34.3K

When implementing algorithms, pay special attention to edge cases, particularly empty collections. Define and documen…

Algorithms

Cross-platform feature flags

⭐ 34.3K

When documenting package installation commands with feature flags, ensure compatibility across different operating sy…

Configurations

Use relative documentation links

⭐ 25.9K

When documenting error handling mechanisms, always use relative path references (`../path/to/file.mdx`) instead of ab…

Error Handling

Review consistency assumptions

⭐ 25.9K

Periodically reassess your database operations based on updated consistency guarantees offered by storage technologie…

Database

Provider instance management

⭐ 25.9K

Ensure proper configuration of provider instances when using environment-specific settings. When using `for_each` wit…

Configurations

Protect infrastructure secrets

⭐ 25.9K

Infrastructure-as-code tools like OpenTofu may store sensitive information in plaintext state files, creating securit…

Security

Document phased migration paths

⭐ 25.9K

When replacing an existing system feature with a new implementation, provide a clear and well-documented phased migra…

Migrations

Contextualize security findings

⭐ 25.9K

When reporting security vulnerabilities, include sufficient context beyond just vulnerability IDs or codes. Always pr…

Security

Clear relationship descriptions

⭐ 25.9K

When documenting algorithms or data structures with graph-like relationships, use precise terminology to describe con…

Algorithms

Use proper testing frameworks

⭐ 2.1K

Always leverage established testing frameworks and APIs over custom bash scripts or direct Python execution for test …

Testing

Track observability API changes

⭐ 2.1K

Stay informed about API changes in observability libraries like OpenTelemetry, especially during their active develop…

Observability

Telemetry version pinning

⭐ 2.1K

When specifying observability frameworks like OpenTelemetry in requirements files, use the compatible release operato…

Observability

Adapt for linter compatibility

⭐ 2.1K

When writing or modifying code, design patterns and templates to be compatible with linting tools. This is especially…

Code Style

Thread-safe resource cleanup

⭐ 82.9K

When implementing resource cleanup in concurrent applications, avoid using deprecated finalizers and instead use Phan…

Concurrency

Maintain build compatibility

⭐ 82.9K

When modifying build scripts or configurations, ensure compatibility across all supported environments and properly t…

CI/CD

Document configuration version requirements

⭐ 82.9K

Make build configuration options explicit and document their version dependencies. When introducing configuration par…

Configurations

Check nulls directly

⭐ 82.9K

Check objects directly for null/empty state instead of using separate tracking variables. Always perform null checks …

Null Handling

Purpose-reflecting file names

⭐ 145.7K

File names should clearly communicate their purpose and functionality. Avoid generic, ambiguous, or numbered names (l…

Naming Conventions

Path traversal prevention

⭐ 145.7K

Implement multiple validation layers to prevent path traversal attacks. File paths provided by users or external syst…

Security

Optimize memory allocations

⭐ 145.7K

Be strategic about memory allocations to improve performance in your C++ code. Consider two key optimization patterns…

Performance Optimization

Model precision matters

⭐ 145.7K

When deploying AI models on specialized hardware accelerators (GPUs, NPUs), ensure you’re using compatible model prec…

Keep container images current

⭐ 145.7K

Always use up-to-date and supported container images in Dockerfiles and configuration files. Before specifying a base…

Configurations

Configurations

Secure permission modeling

⭐ 2.8K

When implementing security-related models such as permissions, carefully design the properties to prevent unauthorize…

Security

Precise and consistent naming

⭐ 2.8K

Names should clearly indicate their specific purpose and context, while maintaining correct capitalization of brand n…

Naming Conventions

File-specific indentation standards

⭐ 2.8K

Maintain consistent indentation based on file type to ensure code readability and prevent unwanted whitespace changes…

Code Style

Validate network request parameters

⭐ 112.2K

Always validate and sanitize all network request parameters to prevent injection attacks. This includes:

1. **URL va…

Security

Secure resource loading

⭐ 112.2K

Always validate and securely load external resources like libraries, configuration files, and modules to prevent tamp…

Security

Descriptive behavior-based tests

⭐ 112.2K

Tests should be named to describe the expected behavior or outcome being verified, not the input parameters or implem…

Testing

Choose appropriate containers

⭐ 112.2K

Select data structures based on expected collection size and usage patterns. For small collections (typically fewer t…

Algorithms

Validate Next.js Configuration Usage

⭐ 133K

When implementing Next.js in your application, ensure that you are correctly using the framework’s documented configu…

Next.js

Robust Error Handling in Next.js Components

⭐ 133K

When building Next.js components, it is crucial to implement robust error handling to ensure the stability and predic…

Next.js

Proper panic chains

⭐ 133K

When implementing panic handlers, follow these critical practices to ensure robust error handling: register panic han…

Error Handling

Non-blocking observability mechanisms

⭐ 133K

When implementing observability mechanisms like telemetry or status monitoring, ensure they don’t block or interfere …

Observability

Document configuration sources

⭐ 133K

When providing configuration instructions, document the exact location and method to obtain required values. Include …

Configurations

Dependency conscious APIs

⭐ 133K

Design APIs with dependency implications in mind. Carefully consider how your API design choices might force dependen…

API

Complete error handling flows

⭐ 133K

Implement robust error handling patterns that ensure both proper resource cleanup and error context preservation.

Error Handling

Complete data structures

⭐ 133K

When implementing data structures such as tries, trees, or graphs, ensure all critical operations (insertion, deletio…

Algorithms

Choose optimal data structures

⭐ 133K

Select data structures based on their performance characteristics and actual usage patterns. When implementing algori…

Algorithms

Enable header validation

⭐ 34.2K

Always enable HTTP header validation to prevent request/response splitting vulnerabilities. These attacks can occur w…

Security

Check feature compatibility

⭐ 34.2K

When using kernel-specific networking features like io_uring, always implement runtime detection of feature support b…

Networking

Test dependency management

⭐ 71.8K

Testing tools and libraries should be placed in `devDependencies` rather than regular dependencies in package.json. R…

Testing

Manage testing dependencies

⭐ 71.8K

Properly manage testing-related dependencies by placing them in devDependencies and regularly auditing them to remove…

Testing

Document CI/CD changes

⭐ 71.8K

Always document changes to CI/CD configurations and scripts, and ensure pull requests remain focused on their intende…

CI/CD

Reliable concurrency synchronization

⭐ 19K

When handling concurrent operations, prefer completion signals and proper thread management over arbitrary timeouts. …

Concurrency

Proper metrics design

⭐ 19K

When designing metrics for observability systems like Prometheus, follow established best practices to ensure your me…

Observability

Optimize what matters

⭐ 19K

Focus optimization efforts on performance-critical paths rather than applying micro-optimizations everywhere. Balance…

Performance Optimization

Modern shell syntax

⭐ 19K

Prefer double brackets (`[[ ]]`) over single brackets (`[ ]`) in shell scripts for improved functionality and consist…

Code Style

Mind transaction boundaries

⭐ 19K

Be conscious of implicit transaction boundaries when working with databases. Programming constructs can create unexpe…

Database

Limit concurrent access slots

⭐ 19K

Design concurrency mechanisms based on actual usage patterns rather than theoretical maximum connections. When implem…

Concurrency

Handle network interrupts safely

⭐ 19K

Network code must properly handle interrupts and maintain consistent connection state at all potential interruption p…

Networking

Feature flag implementation clarity

⭐ 19K

When implementing feature flags in the system, clearly document both the evaluation strategy and its performance impl…

Configurations

Document parameter choices

⭐ 19K

Always add explanatory comments for parameters or configuration options that aren’t self-explanatory from their names…

Documentation

Document connection transitions

⭐ 19K

When implementing systems that involve network connection state changes (such as during failovers, restarts, or compo…

Networking

Database replica promotion safeguards

⭐ 19K

When implementing database replica promotion logic, avoid temporary workarounds that bypass validation checks. Instea…

Database

Balance flexibility with performance

⭐ 19K

When designing APIs, carefully balance flexibility against performance constraints. More flexible APIs often come wit…

API

Use pytest parameterization

⭐ 20.8K

Structure unit tests using pytest’s parameterize decorator instead of manual loops or wrapper functions. This approac…

Testing

⭐ 96.1K

Always implement appropriate security measures for API endpoints that perform sensitive operations. This includes:

1…

Security

Prefer direct property access

⭐ 96.1K

When property names are known at development time, use direct property access (e.g., `object.property`) over computed…

Code Style

Parameterize build processes

⭐ 96.1K

When designing build scripts for multi-package repositories, use parameterization to handle special cases rather than…

CI/CD

Parameter interaction design

⭐ 96.1K

Design APIs with clear parameter interactions and priority rules to create intuitive interfaces. When multiple parame…

API

Optimize CI/CD infrastructure

⭐ 96.1K

Continuously optimize and maintain your CI/CD infrastructure to keep development velocity high while ensuring quality…

CI/CD

⭐ 15K

Always use the correct syntax for accessing environment variables based on the target platform. In JavaScript/Node.js…

Configurations

Match configuration documentation

⭐ 15K

Configuration documentation must accurately reflect implementation details and behavior. Ensure that:

1. Code exampl…

Configurations

Follow standard naming

⭐ 15K

Use established naming patterns and correct capitalization throughout the codebase and documentation.

For test fixt…

Naming Conventions

⭐ 15.1K

Initialize variables with type-appropriate default values to prevent type errors and null reference exceptions during…

Null Handling

⭐ 15.1K

Documentation should be structured to optimize user navigation and information discovery. When organizing documentati…

Documentation

Standardize style scripts

⭐ 15.1K

Maintain consistent code style enforcement scripts across all projects by standardizing linting and formatting config…

Code Style

Standardize metrics collection

⭐ 15.1K

Use the appropriate metric types for the data being collected and consider centralizing monitoring code to ensure con…

Observability

Stable configuration management

⭐ 15.1K

Always ensure configuration values are managed consistently and sourced from stable locations.

1. Use defined const…

Configurations

Safe URL operations

⭐ 15.1K

When handling URLs for API interactions and navigation, use precise methods for both comparison and construction to a…

API

Reduce nesting depth

⭐ 15.1K

Improve code readability by reducing nesting depth with early returns and functional approaches. Use early returns to…

Code Style

Private variable naming convention

⭐ 15.1K

Use the ‘prv’ prefix for private class members and ensure they’re explicitly declared with the ‘private’ access modif…

Naming Conventions

Prefer external configuration

⭐ 15.1K

Design applications to use external configuration sources rather than hardcoding values directly in source code. This…

Configurations

Optimize container build configurations

⭐ 15.1K

Configure containerized application builds to be efficient and flexible by avoiding hardcoded architecture decisions …

CI/CD

Match algorithms to purpose

⭐ 15.1K

Select algorithmic constructs and control structures that are appropriate for the specific task. Common issues includ…

Algorithms

Isolate test cases

⭐ 15.1K

Create separate test functions for distinct functionality to improve test clarity and make failure points more obviou…

Testing

Enforce least privilege

⭐ 15.1K

Configure all systems with the minimum permissions required to function. For Kubernetes deployments, use security con…

Security

Document networking annotations

⭐ 15.1K

When using Istio or other networking-related annotations in configuration files, always include detailed comments exp…

Networking

Document migration paths

⭐ 15.1K

When implementing version changes or migrations, provide comprehensive documentation and tools to support users throu…

Migrations

Descriptive consistent naming

⭐ 15.1K

Use descriptive and consistent names throughout the codebase. Prefer full, meaningful names over acronyms or abbrevia…

Naming Conventions

Consistent separator conventions

⭐ 15.1K

Use appropriate separators in compound identifiers to improve readability and ensure naming consistency across the co…

Naming Conventions

Consistent descriptive naming

⭐ 15.1K

Maintain consistency in naming patterns across related resources while ensuring names accurately reflect their purpos…

Naming Conventions

Component-agnostic styling principles

⭐ 15.1K

Create reusable components with styles that don’t make assumptions about parent contexts or affect their positioning …

Code Style

Centralize dependency configurations

⭐ 15.1K

When adding or updating package dependencies, place them in centralized configuration files rather than duplicating t…

Configurations

Automate style enforcement

⭐ 15.1K

Configure your development environment to automatically enforce code style standards rather than relying on manual ch…

Code Style

API structure balance

⭐ 15.1K

Maintain a clear separation between resource-specific API handlers and common utilities. Resource-specific handlers s…

API

Use modern test infrastructure

⭐ 50.9K

Always add new tests to the current recommended test infrastructure rather than legacy systems that are being phased …

Testing

Minimize not-null assertions

⭐ 50.9K

Avoid using not-null assertions (`!!`) when safer alternatives exist. Instead: 1. Use safe calls (`?.`) when accessin…

Null Handling

Dependency verification configuration

⭐ 50.9K

When adding new dependencies to build.gradle.kts files, always update the corresponding verification metadata to prev…

Configurations

Copy external string inputs

⭐ 50.9K

When storing string pointers from external sources (like command-line arguments), always validate the input and creat…

Null Handling

Document versioning strategies

⭐ 30.3K

Establish and clearly document versioning strategies in configuration files, both for your application and its depend…

Configurations

Document function signatures

⭐ 30.3K

Always document function parameters and return values in the function header comment or interface definition. This is…

Documentation

Centralize workspace configurations

⭐ 30.3K

Centralize configuration settings like dependency versions and feature flags at the workspace level rather than dupli…

Configurations

Semantic naming consistency

⭐ 8.3K

Ensure all model and field names semantically reflect their actual purpose and maintain consistency with their usage …

Naming Conventions

Ensure schema-migration consistency

⭐ 8.3K

When modifying database schemas, ensure complete alignment between schema definitions and SQL migration scripts. Ever…

Migrations

Eliminate documentation redundancy

⭐ 8.3K

Documentation should be concise and avoid repeating the same information in multiple places. Redundant content confus…

Documentation

Consistent code organization

⭐ 8.3K

Maintain consistent patterns when organizing code elements within schema files. Place standard fields (like IDs and t…

Code Style

Collections use plural names

⭐ 8.3K

Always use plural names for properties representing collections (arrays/lists) in interfaces, types, and destructurin…

Naming Conventions

Workflow permission boundaries

⭐ 68.8K

Always define explicit and minimal permission boundaries in GitHub Actions workflows to adhere to the principle of le…

Security

Use dynamic port allocation

⭐ 68.8K

When writing tests that require network services (HTTP, gRPC, or custom protocols), use port 0 to let the operating s…

Networking

Stable test assertions

⭐ 68.8K

Write tests that focus on behavior rather than implementation details to create more stable and maintainable test sui…

Testing

Sort with clarity

⭐ 68.8K

Ensure sorting functions are named to accurately reflect their behavior and implement consistent sorting approaches t…

Algorithms

Opt-in configurable caching

⭐ 68.8K

Implement caching mechanisms as opt-in features with explicit configuration options rather than as defaults. This app…

Caching

Object parameters for readability

⭐ 68.8K

When a function has 3 or more parameters, use object destructuring instead of positional arguments. This improves cod…

Code Style

Document translatable UI text

⭐ 68.8K

All user-facing text in UI components should be properly documented for translation using the application’s internati…

Documentation

Defense in depth

⭐ 68.8K

Always implement multiple layers of security controls, even when they might seem redundant. This strategy ensures pro…

Security

Contextual structured logging

⭐ 68.8K

Log messages should provide sufficient context to be meaningful and actionable while following structured logging pat…

Logging

Check before calculating

⭐ 68.8K

Implement preliminary validation checks before executing expensive operations to avoid unnecessary processing. When h…

Performance Optimization

Balance flexibility with simplicity

⭐ 68.8K

When designing component APIs, strive to find the optimal balance between providing flexible configuration options an…

API

Assert with precision

⭐ 68.8K

Tests should verify actual behavior rather than just successful execution. When writing assertions, favor precise equ…

Testing

Use standard HTTP constants

⭐ 83K

Always use the standard HTTP status constants from the `http` package instead of raw numeric values in your networkin…

Networking

Select algorithms by complexity

⭐ 83K

Choose appropriate algorithms based on computational complexity requirements and context. When implementing lookups, …

Algorithms

Preserve security configurations

⭐ 83K

Always respect explicitly set security attributes and properly sanitize user inputs to prevent security vulnerabiliti…

Security

Pin dependency versions

⭐ 83K

Always specify exact versions of tools and dependencies in CI/CD workflows rather than using ‘latest’ or floating ver…

CI/CD

Minimize configuration complexity

⭐ 83K

Keep configuration files clean and maintainable by regularly reviewing and removing unnecessary settings and outdated…

Configurations

Initialize before null-checking

⭐ 83K

When handling potentially nil values, ensure proper initialization order to prevent race conditions and null referenc…

Null Handling

Document API behavior

⭐ 83K

Thoroughly document how your API endpoints handle data binding and processing, especially non-obvious behaviors that …

API

Declare .PHONY targets

⭐ 83K

Always explicitly declare all Makefile targets that don’t create files as `.PHONY`. This prevents conflicts with pote…

CI/CD

Close resource handles properly

⭐ 83K

Always close file resources and other system handles after use to prevent resource leaks. Resource leaks can cause sy…

Error Handling

Prefer flat control flow

⭐ 32.9K

Minimize code nesting by using Swift features like `guard` statements and early returns instead of deeply nested if-e…

Code Style

Pipeline-friendly script design

⭐ 32.9K

Design scripts to be easily integrated into build pipelines and CI/CD workflows by using standard I/O streams instead…

CI/CD

Generate dynamic configurations

⭐ 32.9K

Always generate configuration files programmatically when they contain dynamic content that changes frequently or nee…

Configurations

Format for readability

⭐ 32.9K

Documentation should be formatted to optimize readability and information retention. Apply these principles to make d…

Documentation

Validate security-critical inputs

⭐ 95.9K

Always implement thorough validation for user-controllable inputs that could pose security risks. Particularly:

1. *…

Security

Use appropriate documentation formats

Clear array operations

⭐ 67.3K

When working with arrays, prioritize clarity and explicitness over terse or clever constructs. For array membership c…

Algorithms

Accurate JSDoc documentation

⭐ 67.3K

Always ensure JSDoc comments accurately reflect the actual code implementation. Parameter types, optionality, and fun…

Documentation

Use current configuration patterns

⭐ 73.1K

Always use the current recommended configuration patterns for your project, avoiding deprecated approaches. When conf…

Configurations

Specify explicit REST formats

⭐ 73.1K

Always specify explicit request formats in REST API tests rather than relying on default behaviors. This includes:

1…

API

Document security requirements explicitly

⭐ 73.1K

Always document security-related configurations, permissions, and behaviors explicitly and comprehensively. When docu…

Security

Document performance tradeoffs

⭐ 73.1K

Always explicitly document the performance implications of API parameters, limit changes, and features that could sig…

Performance Optimization

Complete API parameter documentation

⭐ 73.1K

API endpoints must include comprehensive documentation for all parameters. For each parameter, clearly specify:

1. W…

API

Avoid flaky tests

⭐ 73.1K

Design tests to be deterministic and reliable across different environments. Tests that occasionally fail due to timi…

Testing

Organize by functionality

⭐ 84.2K

Place code in files that match its functionality. When functionality applies to multiple components, use a general-pu…

Code Style

⭐ 14K

AI systems should use the most performant hardware acceleration libraries and carefully manage hardware-specific depe…

Modular adaptive configurations

⭐ 14K

Structure configuration scripts with modularity and adaptability in mind. Extract repeated parameters into variables,…

Configurations

Maintain proper capitalization

⭐ 14K

Always use correct and consistent capitalization for product names, class names, and method names throughout code and…

Naming Conventions

Ensure test determinism

⭐ 14K

Create reliable and reproducible tests by explicitly controlling test inputs and verifying function behavior doesn’t …

Testing

Document in-code decisions

⭐ 14K

Always include explanations for implementation decisions, non-obvious constructs, and specialized functions directly …

Documentation

Document AI implementation references

⭐ 14K

When implementing AI algorithms or neural network operations, document the sources of specific implementation choices…

Functional code examples

⭐ 33.9K

Ensure all code examples in documentation are complete, accurate, and ready to run without modification. Since develo…

Documentation

Fail securely by default

⭐ 33.9K

When designing systems that handle sensitive operations, always default to the most secure behavior rather than prior…

Security

Consistent configuration declarations

⭐ 33.9K

Ensure configuration specifications (such as version requirements, environment settings, and tool declarations) are c…

Configurations

Prefer safe DOM manipulations

⭐ 50.8K

When manipulating DOM content, prefer safer alternatives to innerHTML when possible to prevent Cross-Site Scripting (…

Security

Optimize build scripts

⭐ 50.8K

Improve CI/CD pipeline efficiency by optimizing package.json scripts. Run compatible tasks in parallel using pattern …

CI/CD

Align configurations with usage

salesforce/cloudsplaining

⭐ 50.8K

Configuration files should accurately reflect the actual requirements and characteristics of your codebase. When sett…

Configurations

Configure loggers consistently

⭐ 2.1K

Always configure module-level loggers with a consistent pattern across the codebase. Use `logging.getLogger(__name__)…

Logging

Verify automated documentation

⭐ 7.9K

When using automated tools to generate documentation, always verify the output for accuracy and document any addition…

Documentation

Structure CI/CD scripts

⭐ 7.9K

Improve CI/CD shell scripts’ readability and maintainability by using appropriate shell script patterns. Use heredocs…

CI/CD

Standardize bash error-handling

⭐ 7.9K

Always use `set -eou pipefail` at the beginning of bash scripts to ensure consistent and robust error handling. This …

Error Handling

Log message quality

⭐ 7.9K

Ensure all log messages are consistent in formatting and clear in purpose. Complete sentences in logs should end with…

Logging

Use correct encryption properties

⭐ 7.7K

When configuring security features in Azure ARM templates, always use the correct property names as specified in the …

Security

Target core resources

⭐ 7.7K

When implementing network security checks for serverless functions like AWS Lambda, ensure you target the core functi…

Networking

Secure API endpoints

⭐ 7.7K

Always configure proper authorization for API endpoints to prevent unauthorized access to back-end resources. Avoid c…

API

Minimize workflow complexity

⭐ 7.7K

Keep GitHub Actions workflows efficient and maintainable by eliminating redundant configurations and ensuring compreh…

CI/CD

Lambda CORS protection

⭐ 7.7K

When implementing network security checks for AWS Lambda functions, ensure that CORS (Cross-Origin Resource Sharing) …

Networking

Implement pre-commit hooks

⭐ 7.7K

Automate quality and security checks by implementing pre-commit hooks in your Git repositories to catch issues early …

CI/CD

Ensure dependency compatibility

⭐ 7.7K

When adding or updating dependencies in configuration files (Pipfile, requirements.txt), ensure compatibility with al…

Configurations

Configure security scanners completely

⭐ 7.7K

Security scanning tools must be fully configured to maximize detection capabilities. When implementing tools like Che…

Security

Azure encryption property names

⭐ 7.7K

When configuring encryption settings for Azure resources in ARM templates, always use the correct property names as d…

Security

Validate workflow files

⭐ 79.1K

Ensure all CI/CD workflow configuration files are validated for accuracy and consistency. Small errors in workflow fi…

CI/CD

Validate network inputs

⭐ 79.1K

Network code must validate all inputs and handle error conditions properly to prevent security vulnerabilities and re…

Networking

Validate loop boundary conditions

⭐ 79.1K

When implementing iterative algorithms, ensure comprehensive handling of edge cases and boundary conditions. This inc…

Algorithms

Use branch prediction

⭐ 79.1K

Optimize performance-critical algorithms by using branch prediction hints to guide the CPU. Add `UNLIKELY` macros for…

Algorithms

Thread-safe state transitions

⭐ 79.1K

When modifying shared state in multithreaded code, implement proper checks and state transitions to prevent race cond…

Concurrency

Path comparison precision

⭐ 79.1K

When implementing file path matching or exclusion algorithms, use precise comparison techniques that respect director…

Algorithms

Optimize database interactions

⭐ 79.1K

When working with database operations, prioritize efficiency by avoiding redundant query executions. Instead of execu…

Database

Match API conventions

⭐ 79.1K

Ensure API implementations match established conventions and reference implementations to maintain compatibility and …

API

Judicious move semantics

⭐ 79.1K

Apply C++ move semantics and lambda modifiers only when necessary. The `mutable` keyword should only be used in lambd…

Code Style

Initialize default values

⭐ 79.1K

Always initialize class attributes with default values to prevent AttributeError exceptions when accessing potentiall…

Null Handling

Hide implementation details

⭐ 79.1K

When designing APIs, carefully consider which elements of your implementation become part of the public interface. Av…

API

Function invocation syntax

⭐ 79.1K

Use the appropriate invocation syntax for functions based on their intended usage. Regular functions should be called…

Code Style

Follow standard API specifications

⭐ 79.1K

Ensure API implementations strictly adhere to published specifications, even when adding features or optimizations. D…

API

Document configuration variations

⭐ 79.1K

When documenting or implementing configuration options, always include variations needed for different environments a…

Configurations

Cache repeated accesses

⭐ 79.1K

When accessing the same property or calling the same function multiple times, especially in loops or performance-crit…

Performance Optimization

Resolve naming conflicts clearly

⭐ 44.2K

When naming components, packages, or files that conflict with existing names in your system or related ecosystems, fo…

Naming Conventions

Prefer flags over conditionals

⭐ 44.2K

When implementing environment-specific or version-dependent behavior, use feature flags or configuration variables in…

Configurations

Pin GitHub actions

⭐ 44.2K

Always pin GitHub Actions to specific commit hashes rather than version tags (like @v4). Using version tags is a secu…

Security

Document configuration decisions

⭐ 44.2K

When making configuration changes, especially those that deviate from standard practices or involve deprecation notic…

Configurations

Decouple CI from code

⭐ 44.2K

Separate CI configuration from code that serves other purposes. When variables or settings affect both user-facing be…

CI/CD

Use appropriate comment syntax

⭐ 9.4K

Choose the correct comment syntax based on the file type and processing system to ensure documentation serves its int…

Documentation

Keep CI configurations updated

⭐ 9.4K

Regularly review and update CI configuration files to remove obsolete settings and use appropriate version specificat…

CI/CD

Function-focused code organization

⭐ 9.4K

Files should contain only code related to their named purpose, with proper organization and formatting. When adding f…

Code Style

Follow flake8 style guidelines

⭐ 9.4K

Adhere to the project’s established flake8 style guidelines as defined in setup.cfg. This includes:

1. Maintain line…

Code Style

Avoid identifier name stuttering

⭐ 5.8K

All AI-related dependencies (Microsoft.Extensions.AI.*, etc.) require explicit approval before inclusion and must be …

Address not mask

⭐ 5.8K

Always address the root cause of CI/CD pipeline issues rather than masking them with quick fixes. This applies to enc…

CI/CD

Use Appropriate Concurrency Patterns with Axum

⭐ 22.1K

When building asynchronous Axum applications that share mutable state, it’s important to select the right concurrency…

Axum

Implement Distributed Tracing in Axum Applications

⭐ 22.1K

As an Axum code reviewer, I recommend implementing proper distributed tracing in your Axum-based web applications to …

Axum

User-friendly error messages

⭐ 107K

Error messages should be concise and clearly communicate what went wrong without unnecessary verbosity. When implemen…

Error Handling

Flexible configuration design

⭐ 107K

Design configuration interfaces to be flexible and extensible rather than overly specific. When creating configuratio…

Configurations

Consistent semicolon usage

⭐ 107K

Always terminate statements with explicit semicolons to maintain consistency with the existing codebase style. Avoid …

Code Style

Consistent Axios Usage Patterns

⭐ 107K

Maintain consistent usage of the Axios library throughout your TypeScript codebase. Pay special attention to consiste…

Axios

Standardize API promise patterns

⭐ 7.6K

When adding promise support to API methods, implement a consistent pattern that handles both callback-style and multi…

API

Semantic type organization

⭐ 7.6K

Organize types and interfaces in intuitive namespace hierarchies and use specific types instead of generic ones. Type…

Naming Conventions

Organize type declarations

⭐ 7.6K

Structure TypeScript declarations to improve maintainability and developer experience. Organize related types into ap…

Code Style

Example documentation standards

⭐ 7.6K

Organize API documentation examples for maximum clarity and usefulness. Place hand-written examples before generated …

Documentation

Document sdk version requirements

⭐ 7.6K

Always explicitly document AWS SDK version requirements in your project, and include configuration instructions for d…

Configurations

Complete configuration type definitions

⭐ 7.6K

Ensure configuration type definitions are complete and consistent between global and service-specific settings. When …

Configurations

Accurate type signatures

⭐ 7.6K

When defining API interfaces in TypeScript, ensure that method signatures accurately reflect the actual behavior and …

API

Validate configuration source changes

⭐ 40.9K

When switching between different configuration sources (like APIs or configuration values), ensure data structure com…

Configurations

Use proper access patterns

⭐ 40.9K

Access configurations through documented abstraction layers rather than bypassing them with direct database or low-le…

Configurations

Use guards over assertions

⭐ 40.9K

Prefer explicit type guards and null checks over TypeScript’s type assertions (`as`) when handling potentially null o…

Null Handling

⭐ 40.9K

Use camelCase consistently for all property names, method names, and configuration options, even when interacting wit…

Naming Conventions

⭐ 77.6K

Before implementing custom security documentation or procedures, check if your organization already provides standard…

Security

⭐ 22.1K

Always set appropriate security flags on cookies, especially those used for authentication or session management. At …

Security

Isolate sensitive buffer data

⭐ 7.6K

When handling sensitive data in Node.js, protect against data leakage by isolating sensitive content in dedicated buf…

Security

Prioritize secure token storage

⭐ 40.9K

When implementing authentication token handling, prioritize more secure storage mechanisms over less secure ones. Spe…

Security

Document security exceptions