A Collection of System Prompts for Agentic Code Review

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

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

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

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

Follow Spring Framework's code style guidelines to ensure consistency across the codebase. Key rules include: 1. **I...

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

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

Write code that works across different hardware accelerators by using PyTorch's accelerator abstraction API rather th...

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

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

Reduce object creation in performance-critical paths by carefully evaluating allocation patterns. For frequently inst...

Write code that clearly communicates intent by using appropriate naming and formatting techniques. Improve readabilit...

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

Ensure configuration handling is consistent and platform-agnostic by following these guidelines: 1. Use environment ...

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

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

Select algorithms and data structures that optimize for computational efficiency based on the specific problem requir...

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

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

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

Prioritize code readability over clever solutions by: 1. Using early returns to reduce nesting 2. Leveraging modern P...

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

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

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

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

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

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

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

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

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

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

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

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

All public-facing APIs must be thoroughly documented with clear javadocs. This includes: 1. **Classes and interfaces...

Use explicit identity comparisons for null checks and leverage modern PHP null-handling features to create more relia...

Maintain consistency and accuracy when translating documentation. Ensure technical terms and special formatting eleme...

Choose names that clearly communicate the intent, behavior, and semantics of code elements. Names should be accurate,...

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

Ensure documentation is specific, complete, and actionable for developers: 1. **Provide meaningful content** - Avoid...

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

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

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

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

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

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

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

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

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

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

Always validate performance measurements against expected ranges and understand hardware limitations. When implementi...

Eliminate unnecessary code elements that add cognitive load without providing value. This includes: 1. **Unused para...

Choose identifiers (variable/function/class names) that clearly convey their purpose and follow established conventio...

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

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

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

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

Create clear, comprehensive, and properly structured code samples to document API usage. Follow these principles: 1....

Names in code should be self-documenting, accurately reflect purpose, and follow consistent conventions. Apply these ...

Avoid unnecessary memory allocations in performance-critical code paths. These allocations not only consume memory bu...

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

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

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

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

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

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

When designing APIs, thoroughly document all possible responses your endpoints can return, not just the "happy path" ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Write comprehensive tests that validate both new functionality and edge cases, and organize them systematically to im...

Always check for null/None values and verify attribute/key existence before accessing them. This prevents runtime err...

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

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

Write tests with proper assertions to ensure reliability and maintainability. Follow these guidelines: 1. **Check fo...

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

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

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

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

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

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

Strive to simplify code structure by eliminating unnecessary complexity. This includes: 1. **Move conditions higher ...

Configure CI/CD workflows to trigger precisely based on relevant file path changes. This minimizes unnecessary builds...

In Go, the first letter of an identifier (function, variable, struct field, etc.) determines its visibility outside t...

Always use Gradle's Provider API when accessing project, system, or Gradle properties in your build configuration. Th...

Ensure tests verify both basic functionality and edge cases. Tests that only cover the happy path can miss critical b...

Optimize performance by reducing the amount of computation performed, especially on data that won't appear in the fin...

Maintain code readability and organization by extracting focused, well-named functions and using appropriate scoping....

When designing public APIs, prioritize extensibility while maintaining backward compatibility and implementation hidi...

Always use the testify package (require/assert) in tests instead of standard Go testing assertions. The testify libra...

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

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

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

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

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

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

Use consistent and appropriate naming conventions based on the context in Python code: 1. **Classes**: Use `CamelCas...

Always handle potential null/None values defensively by: 1. Using `.get()` for dictionary access instead of direct ke...

When creating or modifying APIs, carefully consider what becomes part of your public API surface to ensure backward c...

Always verify objects are not null before dereferencing them, particularly when using methods that might return null ...

Always perform explicit null/undefined checks before accessing properties or using values that could be null or undef...

Use Rust's structural patterns to write more idiomatic and maintainable code. This includes: 1. Use early returns to...

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

Error messages should provide clear, actionable information that helps users understand and resolve the problem. Each...

When dealing with Optional values, prefer Rust's built-in Option methods over manual null checks. This makes code mor...

When working with feature flags and conditional compilation, prefer structural approaches over scattered configuratio...

Choose explicit and unambiguous names over concise but unclear ones. When a method, type, or variable has a specific ...

Group related code elements together with a consistent and logical structure. Place stable fields and functionality f...

Be deliberate about memory allocation patterns to improve performance. Implement these practices: 1. **Pre-allocate ...

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

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

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

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

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

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

When writing technical documentation, adhere to these core principles to ensure clarity and effectiveness: 1. **Use ...

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

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

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

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

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

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

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

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

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

Maintain consistent formatting and style in all documentation to improve readability and professionalism: 1. **Use p...

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

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

Focus on writing clean and maintainable code that's easy to read and reason about. This involves several key practice...

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

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

Minimize memory allocations and optimize allocation patterns to improve performance. Key practices: 1. Pre-allocate ...

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

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

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

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

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

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

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

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

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

When iterating through collections, choose the most efficient iteration pattern based on what information you actuall...

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

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

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

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

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

Names should clearly indicate their purpose, type, and behavior. This applies to methods, variables, and parameters. ...

Identify and cache results of expensive operations that may be called repeatedly during a request lifecycle, especial...

Maintain consistent and clear testing patterns by following these guidelines: use strict equality assertions, prefer ...

When running concurrent operations in tests, ensure all operations complete before concluding the test. Race conditio...

When accessing configuration settings, always use the appropriate type-safe accessor methods provided by the configur...

Use precise, informative assertions in tests to provide clear feedback when tests fail and verify the correct behavio...

Always structure concurrent code to use asynchronous callbacks instead of blocking operations. Blocking calls like Co...

Before implementing performance optimizations, measure and validate the impact through benchmarks. This applies espec...

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

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

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

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

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

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

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

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

Add clear, concise comments that explain the "why" behind complex logic, non-obvious decisions, and implicit behavior...

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

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

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

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

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

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

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

Configure dependencies with their minimum necessary scope to maintain clean architecture and improve build times. Key...

When defining configuration options, always clearly document parameter constraints, valid ranges, and behaviors. For ...

Names should clearly reflect their domain-specific meaning and purpose, avoiding generic or ambiguous terms. This app...

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

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

When implementing environment variable configuration: 1. Follow standard environment variable conventions: - Use upp...

Design feature flags to minimize dependency bloat while maximizing flexibility for users. Each optional dependency sh...

Each public API documentation block should follow a consistent structure: 1. Start with a single-line summary that c...

When implementing networking APIs, always clearly document socket modes, configuration options, and platform-specific...

Identify and optimize frequently executed code paths to improve performance. Hot paths have a significant impact on o...

Prioritize graceful error handling over panicking by providing fallbacks and propagating rich context. When operation...

Avoid using real sleeps or delays in tests as they significantly slow down the test suite and can introduce flakiness...

When designing APIs, prioritize flexibility, ergonomics, and intuitiveness to create better user experiences. APIs sh...

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

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

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

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

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

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

Use defensive coding practices to prevent null reference exceptions by properly handling potentially null values thro...

Write tests that are maintainable, self-documenting, and that promote good testing practices: 1. **Use proper assert...

Provide meaningful documentation that enhances code maintainability and understanding. Follow these practices: 1. **...

Avoid recomputing expensive operations by caching results when they will be used multiple times. This applies to meth...

When implementing concurrent code that waits for conditions to be met, avoid busy-wait loops that continuously consum...

When implementing algorithms that operate on complex data structures (trees, graphs, dominator structures), abstract ...

Always provide complete, context-rich code examples in API documentation. Examples should show the full usage context...

Choose the right location and scope for your Rails configuration options to improve maintainability and clarity: 1. ...

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

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

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

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

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

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

Environment variables are a common source of configuration in Python code, but they require proper handling to avoid ...

When implementing platform-specific or version-dependent code, use the simplest and most maintainable configuration g...

When implementing operations that transfer data between devices (particularly CPU to GPU), use device guards and pinn...

When working with hash-based collections like sets or dictionaries, be aware that their ordering is non-deterministic...

Write documentation that serves developers who will read your code months or years from now, not just yourself. When ...

Names should be clear, descriptive, and follow PyTorch's naming conventions. Variable names should precisely convey t...

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

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

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

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

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

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

Prefer efficient memory allocation patterns to improve performance. Key practices: 1. Use RAII containers (like Mat)...

Choose efficient container types and optimize access patterns in performance-critical code. Avoid operations that cau...

Keep code clean and consistent with established project conventions. This includes: 1. Follow existing formatting st...

Configuration management requires careful handling of optional dependencies in both build scripts and source code. Al...

When writing tests, ensure assertions can handle non-deterministic content while providing clear failure context: use...

As a code reviewer, I recommend the following practices to optimize resource utilization when implementing Next.js ap...

Always ensure resources are properly released, especially in exception paths. Use try-finally blocks to guarantee cle...

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

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

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

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

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

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

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

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

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

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

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

Manage environment variables in Docker configurations with appropriate scope, placement, and documentation: 1. **Set...

Store all configuration values in dedicated configuration files rather than hardcoding them throughout the applicatio...

When implementing operations that manipulate collections or perform repeated actions, carefully consider the time com...

Use structured logging with appropriate field types and context to make logs more useful for troubleshooting. Choose ...

Use persistent identifiers for schema elements rather than relying on positional information or enumeration, which ca...

Always make nullable states explicit in your code by leveraging Rust's type system. Use `Option` rather than senti...

Implement comprehensive cache lifecycle management focusing on three key aspects: 1. Idempotent Creation: Make cache...

Ensure code remains readable and maintainable by following these practices: 1. **Combine case statements with identi...

Choose error handling strategies based on operation criticality: 1. For critical operations that could corrupt data ...

Create identifiers that clearly convey meaning through descriptive names and appropriate types. Two key practices imp...

Configuration parameters should be descriptively named, well documented, and have sensible defaults that are visible ...

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

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

When designing APIs, prioritize flexibility and developer experience by: 1. **Accept broader parameter types** - Use...

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

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

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

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

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

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

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

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

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

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

When handling passwords, certificates, or keys in your code, implement secure encryption and storage mechanisms to pr...

Use guard clauses with early returns for null checking instead of wrapping code in conditional blocks. This improves ...

Always define explicit configuration defaults rather than relying on implicit behavior or autovivification. Configura...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Documentation should follow established best practices to ensure clarity, consistency, and usefulness: 1. **Use prop...

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

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

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

Write documentation using direct, clear language that addresses the reader directly. Follow these style guidelines: ...

Applications should gracefully handle different network connectivity states and provide appropriate feedback to users...

Design API authentication mechanisms with consistent patterns, clear documentation, and helpful error messages. When ...

When writing tests, consider both thoroughness and execution time. For operations with significant overhead (like Pyt...

When working with unsafe code, follow these practices to minimize security vulnerabilities: 1. **Minimize scope**: L...

Pay careful attention to operations inside loops and recursive functions to avoid unexpected algorithmic complexity. ...

When using atomic operations, explicitly justify the choice of memory ordering. Each use of a memory ordering should ...

Feature flags should be designed with granularity to ensure dependencies are only required when absolutely necessary....

When writing code that handles potentially null, undefined, or uninitialized values, always document safety assumptio...

When documenting code examples and shell commands in project documentation, follow these formatting standards to ensu...

When implementing mathematical algorithms, ensure precise terminology and correct implementation of mathematical conc...

When using configurable components, clearly document all relevant environment variables and their effects. Include ex...

When designing configuration options, avoid relying on environment-specific defaults such as system character encodin...

When working with Spring annotations, follow these guidelines to avoid common issues: 1. **Use interface types for d...

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

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

Always provide explicit and accurate documentation for security-related configurations, including: 1. Use proper con...

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

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

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

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

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

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

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

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

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

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

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

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

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

Maintain consistent documentation style to improve readability and user experience: 1. **Use precise terminology**: ...

Wildcard (star) imports like `import java.util.*;` are prohibited in the codebase as they reduce code readability and...

Minimize object creation and memory allocations, especially in frequently called methods and hot code paths, to reduc...

Implement automated code style enforcement using complementary tools rather than relying on manual reviews. Configure...

Always catch specific exception types rather than using generic `except Exception` blocks when you know which excepti...

When modifying existing APIs, ensure backward compatibility to prevent breaking dependent code. Changes to function s...

Minimize unnecessary memory operations to improve performance. This includes optimizing memory allocations, initializ...

Design APIs with a focus on simplicity and user experience, especially for first-time users. Complex functionality sh...

Tests should validate specific, well-defined behaviors with clear assertions that directly relate to what's being tes...

Design APIs with intuitive defaults for common use cases while providing specialized options for edge cases. This app...

Choose names that clearly communicate the purpose and behavior of your code elements, focusing on semantic meaning ra...

Always use safe attribute access patterns to handle potentially null or undefined attributes. Instead of direct attri...

When designing configuration options that interact with each other, clearly document these relationships and consider...

When working with configurations in Pydantic models, maintain consistency by using `ConfigDict()` instead of plain di...

Documentation should balance completeness with avoiding redundancy. When documenting complex features: 1. Centralize...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

When working with graph structures, avoid performing redundant depth-first search (DFS) traversals as each traversal ...

Always use explicit null checks (`value is None` or `value is not None`) rather than implicit truthiness evaluations ...

Ensure all API elements are thoroughly documented following a consistent format. This includes: 1. **All function pa...

Eliminate redundant calculations by identifying and caching frequently used values to improve performance. Consider t...

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

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

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

When documenting AI integrations, provide comprehensive examples that showcase all common initialization and usage pa...

Always parameterize values that might vary across different environments or users instead of hardcoding them in your ...

When writing code, favor readability and maintainability over clever or compact solutions. Break down complex logic i...

Explicitly pin version dependencies in configuration files to ensure reproducible builds and prevent breaking changes...

When designing components that require configuration, follow these practices to enhance performance, maintainability,...

When designing APIs, adhere to established API conventions, particularly Kubernetes API conventions when working with...

Create configurations that can be easily managed outside your application code. Design configuration parameters to be...

Always include appropriate documentation in your code to improve readability, maintainability, and usability: 1. **D...

Always provide meaningful context when handling errors, and classify them appropriately based on their source. This i...

Store configuration constants, defaults, and environment variable mappings in dedicated configuration files rather th...

When working with properties or methods that could potentially be null, use Kotlin's null safety features defensively...

Always use structured logging with descriptive field names rather than string interpolation. Include relevant context...

Always verify that pointers, slices, or arrays are non-nil and have sufficient elements before attempting to access t...

Always use configurable values instead of hardcoded defaults when available. This ensures that user preferences are r...

Implement metrics collection that is both comprehensive and minimally impactful on system performance. Design your me...

Always enhance documentation with concrete, illustrative examples that demonstrate expected inputs, formats, or outpu...

When optimizing performance-critical code paths, eliminate redundant operations and unnecessary processing: 1. **Exi...

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

When writing database migration code, prioritize clarity and efficiency to ensure migrations are reliable and maintai...

When writing loops, optimize for both readability and performance by following these key principles: 1. **Exit early...

Keep code coverage tools disabled in CI/CD workflows unless they're specifically needed for generating coverage repor...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Prefer intuitive, user-friendly values for configuration options over technical "magic strings" or codes that require...

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

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

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

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

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

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

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

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

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

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

Enhance code readability and maintainability by applying consistent formatting practices throughout your codebase: 1...

When modifying constraints in database migrations, follow a safe sequence of operations to prevent integrity errors: ...

Write parameterized tests instead of using for loops or duplicating test code for similar test cases. Using pytest's ...

Use Python's built-in efficient collection processing methods instead of manual implementations. This reduces code co...

When consuming APIs in frontend applications, utilize the backend capabilities rather than reimplementing equivalent ...

Always specify explicit version constraints for dependencies in configuration files (like pyproject.toml), particular...

Always prefer explicit configuration parameters over inferring behavior from indirect sources like image tags, naming...

Build SQLAlchemy queries that are both efficient and deterministic to prevent unpredictable results and improve perfo...

Clearly define and document the boundaries between public and internal APIs to guide developers on proper interface u...

Ensure log messages provide clear context about what happened, potential consequences, and actionable information for...

When localizing an application, maintain consistent conventions for technical terms while respecting language-specifi...

Always prioritize reusing existing components before creating new ones. This practice improves codebase consistency, ...

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

Always adhere to the established formatting and syntax conventions of each programming language while maintaining con...

Ensure consistent styling is maintained across related elements in the codebase. This applies to: 1. **Visual assets...

Ensure naming follows consistent patterns throughout the codebase in both style and structure: 1. Use agreed-upon ca...

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

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

Select the appropriate cache sharing approach based on your execution environment to maximize performance and efficie...

Adhere to established naming conventions for files, variables, functions, and configuration options to maintain consi...

Use strong typing and early validation to handle optional values and prevent null-related issues. Prefer enums and sp...

Design APIs that enforce constraints through type systems and declarative mechanisms rather than runtime checks. This...

Structure CI jobs for clarity, parallelism, and efficiency. Each job should have a single, well-defined purpose to pr...

Structure your CI workflows to maximize performance and clarity. Each job should have a single, clear responsibility ...

When writing code that requires unsafe operations, follow these critical security practices: 1. Minimize the scope o...

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

Design machine learning APIs with explicit parameters for distinguishing between training and inference phases rather...

Follow Swift's naming conventions to write more readable, maintainable code. The Swift language emphasizes clarity an...

API documentation should include complete examples that demonstrate all key usage patterns. When documenting related ...

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

Code should be formatted to optimize readability. Apply these key practices: 1. **Maintain reasonable line length** ...

Ensure code follows established Swift naming conventions and remains consistent with domain terminology: 1. Use stan...

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

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

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

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

Utilize Kotlin's null-safety features effectively to create cleaner, more robust code: 1. For class properties that ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

When handling errors, always preserve rich contextual information to make debugging easier and error messages more me...

When designing CI/CD workflows, optimize resource usage while maintaining appropriate test coverage. Consider these g...

Maintain clean and readable configuration files by removing obsolete settings and using clear, maintainable paths. ...

Create reusable scripts or functions for common CI operations instead of duplicating the same logic across multiple C...

Configuration files should follow official standards, have up-to-date tool settings, and appropriate dependency const...

When designing APIs that bridge between programming languages and external data formats (like JSON, XML, etc.), maint...

Always prefer explicit configuration settings over relying on implicit defaults or environmental behaviors in CI work...

Maintain consistent documentation formatting to ensure proper rendering and readability. Follow these key practices: ...

Distinguish between different categories of errors and handle each appropriately. Specifically: 1. **Validation erro...

Design code to work correctly with any combination of feature flags. When implementing conditional compilation with f...

Always prioritize code readability and maintainability over concise but cryptic implementations. Extract repeated log...

When designing database interaction layers, carefully consider when to create wrapper methods versus allowing direct ...

Include clear, concise examples in documentation that effectively demonstrate functionality. Follow these principles ...

Maintain consistent and standardized naming throughout the codebase: 1. **Use snake_case for multi-word identifiers*...

Configure GitHub Actions workflows to maximize reliability and maintainability. Follow these key practices: 1. **Alw...

When implementing AI model inference code, always validate tensor dimensions and shapes before manipulating them. Neu...

Choose names that clearly communicate purpose and follow consistent patterns across the codebase: 1. Use generic fun...

Establish a consistent pattern for feature flags and dependency management in configuration files: 1. Use `WITH_*` o...

Always ensure all resources are properly released before raising errors to prevent resource leaks. This practice is e...

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

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

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

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

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

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

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

When dealing with values that may be absent or null, always use explicit optional type wrappers instead of implicit n...

When writing documentation (README files, tutorials, API docs), ensure clarity and proper formatting: 1. **Define te...

All environment variables must be documented in the central env_var.md file with clear descriptions of their purpose,...

Always provide comprehensive API documentation that clearly specifies: 1. **Parameter types** - Document all accepta...

Use consistent string formatting in logging statements throughout the codebase. Prefer `%` style placeholders over f-...

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

Avoid hardcoded paths and duplicated configuration values throughout the code. Instead: 1. Use dedicated configurati...

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

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

Maintain consistent and explicit naming conventions across your codebase that reflect: 1. **Component dependencies**...

Use specific and consistent naming conventions when referencing AI services, models, and their parameters throughout ...

When processing large arrays or data structures, implement chunked processing to avoid stack size limitations and opt...

When integrating AI models and language processing libraries, follow these dependency management best practices: 1. ...

In Go, prefer table-driven tests over multiple separate test functions. Table tests allow for concise testing of mult...

Follow Python's PEP 8 naming convention by using snake_case for variables, functions, and methods rather than camelCa...

Always match logging levels to the message's purpose and severity. Use log.Info for general information, log.Warn for...

OWNERS files must follow project documentation standards to properly reflect component ownership and maintainership. ...

All components should use consistent build configurations and patterns in their CI/CD setup. This includes standardiz...

When documenting network access methods or service connections, always provide specific commands with explicit ports ...

When handling URLs in web applications, consistently normalize path formats to prevent routing and service communicat...

All user-facing text in HTML templates should be marked for internationalization using the i18n directive. This inclu...

Carefully manage configuration file changes to ensure consistency and minimize unintended impacts across your project...

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

Write informative, consistent, and precise code comments throughout your codebase. When documenting code: 1. **Be sp...

Always validate that objects, maps, and other reference types are non-nil before attempting to use them. Use early ni...

Maintain consistent and standardized build configurations across the project to improve maintainability and reduce er...

Use domain-specific types instead of primitives (like strings, []byte, or generic maps) to represent domain concepts ...

Implement comprehensive lifecycle controls for authentication tokens to maintain security throughout token creation, ...

Security-critical features should be implemented as required parameters rather than optional parameters or option fun...

When documenting database systems, ensure all documentation includes complete end-to-end data flows. Both diagrams an...

When working with database systems that have flexible schemas (like InfluxDB), ensure complete schema discovery and p...

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

When supporting multiple library versions or preparing for version deprecation in configuration-dependent code, use s...

Implement secure authentication using JWT tokens by following these best practices: 1. **Use secure libraries**: Pre...

When designing APIs, ensure responses adhere to HTTP semantics by: 1. Using semantic status code constants instead o...

When implementing partial updates in FastAPI, use the `exclude_unset` parameter in Pydantic's `.dict()` or `.model_du...

Always be explicit about how exceptions are handled, propagated, and recovered from in your code. When catching excep...

When implementing operations that consume significant system resources (CPU, memory, I/O), introduce changes graduall...

When designing and implementing configuration options, carefully consider two key aspects: 1. **Choose appropriate c...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use proper naming conventions to make code more readable and maintainable: 1. **Functions should start with verbs** ...

Implement strict authentication boundaries and access controls to prevent security vulnerabilities: 1. When multiple...

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

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

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

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

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

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

Ensure that code paths handling different deployment environments (installation prefixes, target directories, etc.) h...

Leverage Docker BuildKit's cache and bind mount capabilities to dramatically improve CI build times and reduce image ...

When setting Rust build configurations, especially in CI/Docker environments, explicitly document optimization choice...

When implementing caching in build systems, carefully configure cache sharing behavior based on your concurrency requ...

When specifying dependencies and version requirements in project configuration files, avoid adding unnecessary constr...

Include testing configurations that mirror production environments to catch issues that might only manifest in releas...

Configure test suites to run under multiple specialized environments to catch issues that might not appear in standar...

Keep configuration flags, feature toggles, and build settings concise and well-organized. Use simpler names where app...

Maintain consistent Swift style conventions throughout all code, including examples in documentation and comments. Fo...

Data transfers between different compute devices (CPU/host to GPU/accelerator and back) can significantly impact perf...

When designing and documenting APIs in Swift, adhere to Swift's established naming conventions and documentation prac...

When implementing algorithms that process collections or use conditional logic, always verify the exact semantics of ...

Utilize Asciidoc features correctly when writing or updating Spring Framework documentation. Instead of hardcoded lin...

Design log messages to be clear, concise, and properly structured to maximize their utility for debugging and monitor...

Always use stable, production-ready versions of observability components (libraries, dependencies, and documentation ...

When implementing database migrations with tools like Flyway, ensure you include the appropriate database-specific de...

When working with environment variables in configuration files, follow these practices to ensure reliability and test...

When referring to technical concepts in documentation and code comments, use proper full names and consistent termino...

Document structured logging implementations with clarity, explicitly noting precedence rules and interactions with ot...

When using containers and external services in Spring applications (especially with Testcontainers), declare them as ...

Use predefined utility macros for common operations instead of repeating manual calculations throughout your code. Th...

When implementing performance-critical algorithms, design your code to detect and utilize platform-specific hardware ...

Always use proper memory alignment for SIMD (Single Instruction, Multiple Data) operations to maximize performance. W...

Name variables, properties, and functions to accurately reflect their purpose and actual usage in code, not just thei...

When implementing low-level synchronization mechanisms in multi-threaded code, ensure that memory barriers are correc...

When modifying configuration systems, prioritize backward compatibility unless there's an explicit breaking change pl...

When implementing or modifying APIs, carefully preserve the historical behavior and semantic contracts of existing in...

When implementing feature flags, ensure consistency between runtime and compiled scenarios. Feature switches marked w...

When extending interfaces with new methods or functionality, always implement proper versioning to ensure compatibili...

Always provide configurable options for performance instrumentation and hardware acceleration in your codebase. These...

Add clear comments explaining the purpose and reasoning behind complex or non-obvious code logic. Comments should exp...

Always document function contracts completely, even when surrounding code lacks documentation. Include header comment...

Platform-specific code and API usage should be centralized in designated configuration files rather than scattered th...

Structure conditionals for maximum clarity and comprehension. Avoid unnecessary negation in boolean expressions, use ...

When working with URLs in networking code, always use the standard `URL` constructor to properly resolve relative URL...

When using the React library in Typescript, ensure that you are correctly implementing the recommended React hooks ba...

When implementing React components, it is important to ensure that variables are properly scoped and used throughout ...

When creating configuration files for development environments that use multiple technology stacks, ensure settings a...

When implementing Content Security Policy (CSP) protections, always explicitly pass nonce values to components rather...

Apply DRY (Don't Repeat Yourself) principles to all configuration files to improve maintainability. Extract shared co...

Add clear comments that explain the intent and behavior of code that might not be immediately obvious to other develo...

When working with React components that may return null or undefined values, implement defensive coding patterns to p...

Create reusable helper methods for common testing operations to improve test maintainability and consistency. Design ...

When developing Quarkus extensions that interact with classes containing Spring annotations (like `@Service`, `@Compo...

When implementing metrics and telemetry in your application, avoid using dynamic values like path parameters or user ...

When implementing algorithms that process large data structures or complex computational paths, prioritize opportunit...

Always use the latest stable and supported versions in configuration files. This applies to runtime environments, bui...

When implementing observability features like OpenTelemetry exporters, metrics collection, or distributed tracing, cl...

When designing HTTP-related APIs, prioritize readability and intuitiveness through well-crafted fluent interfaces. AP...

Maintain a single source of truth for configuration files instead of duplicating them across the codebase. Duplicated...

Ensure code is protected against memory-related security vulnerabilities by properly handling type conversions and re...

PyTorch documentation should be comprehensive and include proper cross-references to related content. This means: 1....

Using concrete types instead of abstract container classes in data models improves validation performance. More speci...

Use automated linting tools to enforce consistent code style across the project, but be deliberate about which rules ...

Ensure data structures are accurately represented with their proper constraints and valid implementations, particular...

Check conditions early to skip unnecessary processing and reuse computed values where possible to optimize performanc...

When implementing or modifying temporal operations, maintain consistent data types that align with existing temporal ...

When implementing algorithms, pay special attention to edge cases, particularly empty collections. Define and documen...

When documenting package installation commands with feature flags, ensure compatibility across different operating sy...

When implementing resource cleanup in concurrent applications, avoid using deprecated finalizers and instead use Phan...

When modifying build scripts or configurations, ensure compatibility across all supported environments and properly t...

Make build configuration options explicit and document their version dependencies. When introducing configuration par...

Check objects directly for null/empty state instead of using separate tracking variables. Always perform null checks ...

When implementing Next.js in your application, ensure that you are correctly using the framework's documented configu...

When building Next.js components, it is crucial to implement robust error handling to ensure the stability and predic...

When implementing panic handlers, follow these critical practices to ensure robust error handling: register panic han...

When implementing observability mechanisms like telemetry or status monitoring, ensure they don't block or interfere ...

When providing configuration instructions, document the exact location and method to obtain required values. Include ...

Design APIs with dependency implications in mind. Carefully consider how your API design choices might force dependen...

Implement robust error handling patterns that ensure both proper resource cleanup and error context preservation.

When implementing data structures such as tries, trees, or graphs, ensure all critical operations (insertion, deletio...

Select data structures based on their performance characteristics and actual usage patterns. When implementing algori...

When using kernel-specific networking features like io_uring, always implement runtime detection of feature support b...

Structure unit tests using pytest's parameterize decorator instead of manual loops or wrapper functions. This approac...

In AI model implementations, avoid using magic numbers directly in code as they reduce readability and make maintenan...

When data will be accessed multiple times during processing, avoid redundant calculations by pre-computing values upf...

Maintain high-quality, consistent documentation as a critical component of API design. Documentation should feature: ...

When adding new files or components to the project, ensure that documentation configuration is updated accordingly. T...

Maintain clean code organization by eliminating unnecessary abstractions and preventing codebase fragmentation. This ...

Always use the correct syntax for accessing environment variables based on the target platform. In JavaScript/Node.js...

Configuration documentation must accurately reflect implementation details and behavior. Ensure that: 1. Code exampl...

Use established naming patterns and correct capitalization throughout the codebase and documentation. For test fixt...

When implementing AI model optimization techniques such as early stopping algorithms or hyperparameter tuning, includ...

Always validate input parameters and respond with appropriate HTTP status codes when invalid values are detected, eve...

When handling nullable or undefined states, use enumerations instead of primitive types like boolean or null/undefine...

Avoid inline styles and `!important` declarations in your HTML templates. Instead, define and use CSS classes that en...

When defining CI/CD workflows, always ensure task/step names are unique to prevent execution failures. Workflow engin...

Initialize variables with type-appropriate default values to prevent type errors and null reference exceptions during...

Documentation should be structured to optimize user navigation and information discovery. When organizing documentati...

Maintain consistent code style enforcement scripts across all projects by standardizing linting and formatting config...

Use the appropriate metric types for the data being collected and consider centralizing monitoring code to ensure con...

Always ensure configuration values are managed consistently and sourced from stable locations. 1. Use defined const...

When handling URLs for API interactions and navigation, use precise methods for both comparison and construction to a...

Improve code readability by reducing nesting depth with early returns and functional approaches. Use early returns to...

Use the 'prv' prefix for private class members and ensure they're explicitly declared with the 'private' access modif...

Design applications to use external configuration sources rather than hardcoding values directly in source code. This...

Configure containerized application builds to be efficient and flexible by avoiding hardcoded architecture decisions ...

Select algorithmic constructs and control structures that are appropriate for the specific task. Common issues includ...

Create separate test functions for distinct functionality to improve test clarity and make failure points more obviou...

Configure all systems with the minimum permissions required to function. For Kubernetes deployments, use security con...

When using Istio or other networking-related annotations in configuration files, always include detailed comments exp...

When implementing version changes or migrations, provide comprehensive documentation and tools to support users throu...

Use descriptive and consistent names throughout the codebase. Prefer full, meaningful names over acronyms or abbrevia...

Use appropriate separators in compound identifiers to improve readability and ensure naming consistency across the co...

Maintain consistency in naming patterns across related resources while ensuring names accurately reflect their purpos...

Create reusable components with styles that don't make assumptions about parent contexts or affect their positioning ...

When adding or updating package dependencies, place them in centralized configuration files rather than duplicating t...

Configure your development environment to automatically enforce code style standards rather than relying on manual ch...

Maintain a clear separation between resource-specific API handlers and common utilities. Resource-specific handlers s...

Always add new tests to the current recommended test infrastructure rather than legacy systems that are being phased ...

Avoid using not-null assertions (`!!`) when safer alternatives exist. Instead: 1. Use safe calls (`?.`) when accessin...

When adding new dependencies to build.gradle.kts files, always update the corresponding verification metadata to prev...

When storing string pointers from external sources (like command-line arguments), always validate the input and creat...

Establish and clearly document versioning strategies in configuration files, both for your application and its depend...

Always document function parameters and return values in the function header comment or interface definition. This is...

Centralize configuration settings like dependency versions and feature flags at the workspace level rather than dupli...

When specifying testing library dependencies, always use explicit minimum patch versions rather than development bran...

Always use the `#[\SensitiveParameter]` attribute for parameters containing sensitive information such as passwords, ...

Use explicit type assertions in TypeScript tests to verify that types behave as expected across various scenarios. In...

When configuring Git operations in GitHub Actions workflows, especially for automated commits, use the GitHub Actions...

When designing logging interfaces, create flexible APIs that accommodate both standard and custom logging needs. This...

This review focuses on secure implementation patterns when using the Fastify web framework in Typescript: prevent Pro...

When constructing URLs with IP addresses, ensure IPv6 addresses are properly formatted according to RFC standards by ...

When working with Fastify decorators, always perform explicit null checks before accessing potentially undefined prop...

When implementing code using the Fastify package in Typescript, it is important to use consistent and accurate naming...

When naming variables, functions, routes, and other code elements, use clear, neutral terminology that will be unders...

When processing large files or datasets, implement generator functions that yield data incrementally rather than load...

Choose the most suitable documentation format based on context to maximize readability and information value. For P...

FastAPI's performance advantage comes from its asynchronous foundation built on Starlette and Uvicorn, using `uvloop`...

Configure database connections differently based on the environment. Use lightweight file-based databases like SQLite...

When updating dependency version constraints in requirements files, ensure consistency with versions pinned by other ...

Error messages should be clear, specific, and provide enough context to understand the issue without exposing unneces...

When working with asynchronous code, ensure that I/O operations (like file reads/writes) don't block the event loop. ...

Always use the current recommended configuration patterns for your project, avoiding deprecated approaches. When conf...

Always specify explicit request formats in REST API tests rather than relying on default behaviors. This includes: 1...

Always document security-related configurations, permissions, and behaviors explicitly and comprehensively. When docu...

Always explicitly document the performance implications of API parameters, limit changes, and features that could sig...

API endpoints must include comprehensive documentation for all parameters. For each parameter, clearly specify: 1. W...

Design tests to be deterministic and reliable across different environments. Tests that occasionally fail due to timi...

When using automated tools to generate documentation, always verify the output for accuracy and document any addition...

Improve CI/CD shell scripts' readability and maintainability by using appropriate shell script patterns. Use heredocs...

Always use `set -eou pipefail` at the beginning of bash scripts to ensure consistent and robust error handling. This ...

Ensure all log messages are consistent in formatting and clear in purpose. Complete sentences in logs should end with...

Regularly review and update CI configuration files to remove obsolete settings and use appropriate version specificat...

Files should contain only code related to their named purpose, with proper organization and formatting. When adding f...

Adhere to the project's established flake8 style guidelines as defined in setup.cfg. This includes: 1. Maintain line...

Do not repeat the resource name in identifier names. This form of stuttering makes code less readable and inconsisten...

When implementing observability for Azure services, prefer higher-level telemetry packages and configuration methods ...

When working with network protocols (like AMQP, NFS, or SMB), maintain the integrity of the original protocol data st...

Always use the same build and test commands locally that are used in your CI pipeline to ensure consistency between e...

When calling external processes (like dotnet, msbuild, etc.), always implement proper error handling and output manag...

Reduce code duplication by extracting repeated patterns into variables, loops, or helper functions. When you find you...

Add clarifying comments to code elements whose purpose or behavior may not be immediately apparent to other developer...

Add clear documentation for any decisions that affect future code maintenance. This includes: 1. Providing explanato...

When updating AI libraries and SDKs, ensure all changes are thoroughly documented in changelogs with clear categoriza...

Ensure all CI/CD configuration files have their required fields properly populated with specific values rather than e...

All AI-related dependencies (Microsoft.Extensions.AI.*, etc.) require explicit approval before inclusion and must be ...

Always address the root cause of CI/CD pipeline issues rather than masking them with quick fixes. This applies to enc...

When building asynchronous Axum applications that share mutable state, it's important to select the right concurrency...

As an Axum code reviewer, I recommend implementing proper distributed tracing in your Axum-based web applications to ...

Error messages should be concise and clearly communicate what went wrong without unnecessary verbosity. When implemen...

Design configuration interfaces to be flexible and extensible rather than overly specific. When creating configuratio...

Always terminate statements with explicit semicolons to maintain consistency with the existing codebase style. Avoid ...

Maintain consistent usage of the Axios library throughout your Typescript codebase. Pay special attention to consiste...

When adding promise support to API methods, implement a consistent pattern that handles both callback-style and multi...

Organize types and interfaces in intuitive namespace hierarchies and use specific types instead of generic ones. Type...

Structure TypeScript declarations to improve maintainability and developer experience. Organize related types into ap...

Organize API documentation examples for maximum clarity and usefulness. Place hand-written examples before generated ...

Always explicitly document AWS SDK version requirements in your project, and include configuration instructions for d...

Ensure configuration type definitions are complete and consistent between global and service-specific settings. When ...

When defining API interfaces in TypeScript, ensure that method signatures accurately reflect the actual behavior and ...

When switching between different configuration sources (like APIs or configuration values), ensure data structure com...

Access configurations through documented abstraction layers rather than bypassing them with direct database or low-le...

Prefer explicit type guards and null checks over TypeScript's type assertions (`as`) when handling potentially null o...

Always quote shell script variable expansions using double quotes to prevent word splitting issues and ensure consist...

When designing CI/CD workflows, prioritize both resource efficiency and clear documentation. Incorporate dynamic conf...

When providing translations for user interface elements and documentation, prioritize natural and idiomatic expressio...

Applications that may need elevated privileges should explicitly warn against running the entire application with sud...

Always mask sensitive tokens, credentials, and secrets in CI/CD workflows to prevent accidental exposure in logs or b...

Always use appropriate validation mechanisms for security-sensitive inputs to prevent vulnerabilities. When implement...

Before implementing custom security documentation or procedures, check if your organization already provides standard...

Always use constant-time comparison methods when validating cryptographic values to prevent timing side-channel attac...

When implementing security features (such as artifact signing), use current best practices and prefer pure-Java secur...

When implementing authentication or handling credentials, always redact sensitive information (keys, tokens, password...

When handling security-related attributes (like nonces, integrity hashes, or CSP directives), always document the log...

Always decode URL paths before performing security validations to prevent bypass attacks using URL encoding. Security...

Never use the `eval()` function in Python code as it creates serious security vulnerabilities by executing arbitrary ...

Never expose security vulnerabilities in public issue trackers. Security issues require confidential handling to prev...

Never directly concatenate untrusted data (like user inputs or API responses) into HTML strings, as this creates cros...

When building container images, ensure they're compatible with restricted Kubernetes security contexts. Use numeric U...

Always validate that URLs use the HTTPS protocol in both implementation code and validation error messages. Even if y...

Make security features configurable through environment variables or configuration files, but always implement secure...

Always document non-obvious security implementations, especially authentication mechanisms, with explanatory comments...

When introducing new dependencies, especially those handling sensitive operations like language interpreters, perform...

When implementing Content-Type validation, ensure regular expressions start with '^' or include ';?' to properly dete...

Always assign the minimum permissions necessary for functionality when implementing role-based access controls. This ...

Regularly audit and update third-party libraries and dependencies to address known security vulnerabilities. Pay spec...

When including API keys, access tokens, or other credentials in documentation, examples, or test code, always use cle...

Always sanitize configuration data or any potentially sensitive information before logging or displaying it. When log...

Never hardcode sensitive values such as client identifiers, API keys, connection strings, or passwords directly in co...

Always verify both positive and negative authentication scenarios in your security tests. For each authentication mec...

Always set appropriate security flags on cookies, especially those used for authentication or session management. At ...

When handling sensitive data in Node.js, protect against data leakage by isolating sensitive content in dedicated buf...

When implementing authentication token handling, prioritize more secure storage mechanisms over less secure ones. Spe...

When disabling security-related linter rules or bypassing security best practices, always include comments that expla...