documentation clarity standards
remix-run/react-routerEnsure all React-related documentation, comments, and descriptions maintain high standards of clarity, accuracy, and ...
Use runServerless utility
serverless/serverlessAll new tests must be written using the `runServerless` utility instead of legacy testing approaches. This utility pr...
Complete locale translations
RooCodeInc/Roo-CodeEnsure that all text strings in locale-specific files are properly translated into their respective languages. Leavin...
Use environment variables
hashicorp/terraformWhen working with configurations that require sensitive data (credentials, tokens, passwords), always use environment...
reduce complexity for readability
servo/servoPrioritize code readability by reducing complexity through better organization and clearer patterns. Use early return...
Prevent sensitive data exposure
bridgecrewio/checkovNever log or store sensitive information (passwords, tokens, secrets) in clear text. This common security vulnerabili...
Use descriptive names
strands-agents/sdk-pythonChoose names that clearly convey purpose and intent rather than generic or ambiguous terms. Names should be specific ...
API authentication requirements
langflow-ai/langflowEnsure all API documentation and code examples include proper authentication headers and clearly explain authenticati...
configuration value consistency
traefik/traefikEnsure configuration values follow consistent formats, use meaningful defaults, and accurately distinguish between re...
Complete network configurations
traefik/traefikNetwork configuration examples and documentation should include all essential networking components such as ports, pr...
Optimize allocation hotspots
netty/nettyIdentify and optimize object allocation in performance-critical paths by applying appropriate allocation strategies b...
Configuration documentation clarity
langflow-ai/langflowEnsure configuration documentation clearly distinguishes between deployment contexts and uses consistent terminology ...
no braces short ifs
hyprwm/HyprlandRemove braces around single-statement if blocks to maintain consistent code style and improve readability. This appli...
Use meaningful names
juspay/hyperswitchUse descriptive, self-explanatory names for variables, methods, fields, and types. Avoid single-letter variables, abb...
optimize database operations
apache/sparkWhen working with database operations, prioritize batching multiple statements and pushing operations down to the dat...
Use descriptive semantic names
serverless/serverlessVariable and function names should clearly communicate their purpose, type, and scope without requiring additional co...
Validate boundary conditions
rust-lang/rustEnsure algorithms handle boundary conditions and edge cases correctly by adding explicit validation for all input ran...
documentation formatting consistency
nuxt/nuxtEnsure consistent formatting throughout documentation by applying these standards: wrap code terms, variable names, a...
Comprehensive test coverage
kubernetes/kubernetesEnsure comprehensive test coverage by systematically considering all scenarios, edge cases, and feature combinations ...
Extract for clarity
elastic/elasticsearchExtract complex or reused logic into focused, well-named methods with single responsibilities. This improves code rea...
Protect sensitive data
bridgecrewio/checkovNever log, display, or store sensitive information like passwords, tokens, or secrets in clear text. This creates sig...
Comprehensive documentation standards
tokio-rs/axumCreate clear, well-structured API documentation following proper formatting, correct references, informative examples...
Use descriptive names
vlang/vChoose variable, function, and parameter names that clearly communicate their purpose and avoid confusion. Names shou...
realistic documentation examples
sveltejs/svelteUse practical, complete examples in documentation rather than oversimplified or contrived ones that cut corners. Docu...
Avoid code duplication
BerriAI/litellmEliminate redundant code by leveraging existing utilities, extracting reusable helper functions, and organizing logic...
Organize code structure
juspay/hyperswitchMaintain clean and well-organized code structure by following consistent organizational patterns. This improves reada...
Explain non-obvious code
flutter/flutterAdd explanatory comments for any code that isn't immediately self-explanatory, including magic numbers, implementatio...
Use specific assertion methods
fastify/fastifyChoose the appropriate assertion method based on the data type being tested. This improves test readability and provi...
Database type consistency
drizzle-team/drizzle-ormEnsure database-specific types, imports, and serialization are used consistently throughout the codebase. This preven...
Use descriptive, unambiguous names
bazelbuild/bazelChoose names that clearly communicate their purpose and avoid ambiguity or misinterpretation. Names should be self-do...
Simplify complex code
bazelbuild/bazelBreak down complex code structures into simpler, more readable forms to improve maintainability and reduce cognitive ...
Consistent terminology propagation
appwrite/appwriteWhen changing terminology or naming conventions in a codebase, ensure complete and consistent propagation across all ...
eliminate unnecessary code
Unstructured-IO/unstructuredRemove redundant operations, unnecessary code blocks, and verbose constructs to improve code clarity and maintainabil...
Optimize regex patterns
getsentry/sentry-phpWhen using regular expressions, optimize for both performance and precision to ensure efficient and accurate pattern ...
Internationalize all text
RooCodeInc/Roo-CodeAll user-facing text must be wrapped with translation functions instead of using hardcoded English strings. This incl...
Consistent naming patterns
octokit/octokit.netFollow consistent naming conventions throughout the codebase to improve readability and maintainability: 1. **Client...
Guard against null
n8n-io/n8nAlways use optional chaining (`?.`) and nullish coalescing (`??`) operators when accessing potentially undefined or n...
Handle async operation errors
elie222/inbox-zeroAlways wrap asynchronous operations in try-catch-finally blocks to prevent unhandled promise rejections and ensure pr...
Keep CI configurations minimal
laravel/frameworkWhen configuring CI workflows, include only the extensions, tools, and settings that are necessary for the specific t...
SQLAlchemy 2.0 patterns
langgenius/difyMigrate from legacy SQLAlchemy 1.x query patterns to modern 2.0 style for better performance, clarity, and future com...
Consistent naming standards
home-assistant/coreEnsure all user-facing strings follow Home Assistant's naming conventions for consistency and proper internationaliza...
Configuration validation messages
cloudflare/workers-sdkEnsure configuration validation provides clear, actionable error messages that guide users toward correct configurati...
avoid expensive repeated operations
vlang/vCache results of expensive computations and order operations from cheapest to most expensive to minimize performance ...
Add comprehensive test coverage
vlang/vWhen adding functionality or fixing bugs, always add new test functions rather than modifying existing ones to preser...
Enforce scope boundaries
gravitational/teleportWhen implementing hierarchical permission systems with scopes, ensure that permissions granted at a specific scope ca...
Spring code style
spring-projects/spring-frameworkFollow Spring Framework's code style guidelines to ensure consistency across the codebase. Key rules include: 1. **I...
Use semantically accurate names
servo/servoVariable, method, and type names should accurately reflect their actual purpose, content, and behavior. Avoid generic...
Consistent descriptive naming
prometheus/prometheusEnsure variable, function, and type names are consistent, descriptive, and follow Go naming conventions. Names should...
Code for readability
opencv/opencvPrioritize human readability when writing code. Split complex expressions into steps with meaningful variable names. ...
Descriptive consistent naming
ghostty-org/ghosttyUse descriptive, consistent naming that follows language and platform conventions. Choose names that clearly communic...
Use descriptive names
flutter/flutterNames should clearly describe what they represent or do, rather than how they're implemented or using generic terms. ...
API parameter consistency
electron/electronEnsure consistent parameter handling across API methods by using appropriate defaults, proper type conversion, valida...
Clean up your code
deeplearning4j/deeplearning4jMaintain clean, professional code by removing development artifacts and improving readability: 1. **Remove debug cod...
Use descriptive contextual names
alacritty/alacrittyChoose variable, function, and struct names that clearly communicate their purpose and content while considering thei...
Design interfaces, not implementations
zed-industries/zedCreate intuitive API interfaces that abstract away implementation details while providing a consistent experience for...
Use testify assertion libraries
vitessio/vitessReplace manual if-error checks with `testify`'s `assert` and `require` packages to make tests more readable, maintain...
Use semantically clear names
Unstructured-IO/unstructuredChoose variable, method, and class names that clearly express their purpose and functionality to avoid confusion and ...
simplify control flow patterns
twentyhq/twentyImprove code readability by simplifying control flow structures and avoiding unnecessary complexity. This involves th...
Simplify complex expressions
tree-sitter/tree-sitterBreak down complex code structures into simpler, more readable forms. This includes avoiding deep nesting, extracting...
Configuration validation consistency
traefik/traefikEnsure configuration fields use consistent validation patterns, appropriate data types, and proper bounds checking. T...
Use semantic naming
microsoft/terminalNames should clearly communicate their purpose, type, and behavior to improve code maintainability and accessibility....
Guide structure consistency
gravitational/teleportDocumentation guides should follow a consistent structure and provide clear, descriptive content to improve user expe...
consistent descriptive naming
SigNoz/signozUse meaningful, descriptive names that clearly convey purpose and maintain consistency across similar concepts throug...
eliminate code duplication
sgl-project/sglangActively identify and eliminate code duplication by extracting common patterns into reusable components. When you not...
API consistency patterns
remix-run/react-routerEnsure API design follows consistent patterns for naming, typing, and composition to improve developer experience and...
Parameterize similar tests
python-poetry/poetryUse `pytest.mark.parametrize` to consolidate similar test cases instead of duplicating test code. This approach impro...
Component naming consistency
n8n-io/n8nEnsure component usage in templates matches registered components. Vue components must be referenced in templates by ...
Clean and consistent code
n8n-io/n8nMaintain clean and consistent code by removing unnecessary elements and following standard practices: 1. **Remove co...
Eliminate redundant constructs
apache/mxnetRemove unnecessary coding patterns that add complexity without providing value. Focus on clarity and simplicity by: ...
Model specification accuracy
lobehub/lobe-chatEnsure AI model configurations accurately reflect official specifications and avoid hardcoded assumptions. Model para...
prefer OpenAI compatibility
BerriAI/litellmWhen integrating new LLM providers or AI services, prioritize OpenAI-compatible patterns and reuse existing utilities...
Mock tests in tests/litellm
BerriAI/litellmAll new functionality must include mock tests placed in the `tests/litellm/` directory structure. Mock external API c...
Use descriptive names
istio/istioNames should accurately reflect their actual functionality and behavior. Avoid misleading or vague identifiers that d...
consistent highlighting patterns
helix-editor/helixMaintain consistency in syntax highlighting patterns by using appropriate, specific scopes and avoiding overly comple...
Use extensible parameter objects
electron/electronWhen designing APIs that may need additional parameters in the future, use objects instead of individual parameters t...
Provide contextual explanations
electron/electronDocumentation should explain not just what APIs and features do, but when, why, and how to use them. Provide sufficie...
Use descriptive identifiers
discourse/discourseChoose names that clearly communicate purpose and reduce cognitive load for future readers. Avoid generic, abbreviate...
Follow existing naming patterns
docker/composeMaintain consistency with established naming conventions throughout the codebase. When adding new flags, functions, o...
consistent readable patterns
snyk/cliMaintain consistent coding patterns and prioritize readability to make code easier to understand and maintain. This i...
Limit token permissions
chef/chefAlways specify the minimum required permissions for the GITHUB_TOKEN in GitHub Actions workflows to enhance security....
Maintain consistent style
oven-sh/bunMaintain consistent style patterns throughout the codebase to improve readability, reduce maintenance overhead, and p...
Follow support tiers
Homebrew/brewConfigure your Homebrew installation according to the defined support tiers to ensure optimal functionality and suppo...
maintain consistent style
angular/angularEnsure consistent application of coding style conventions throughout the codebase, including naming patterns, type us...
Use descriptive naming
volcano-sh/volcanoChoose variable, function, and method names that clearly communicate their purpose and behavior. Avoid ambiguous abbr...
Optimize algorithmic efficiency
volcano-sh/volcanoChoose efficient algorithms and data structures to minimize computational overhead and improve code maintainability. ...
Eliminate code redundancy
vllm-project/vllmKeep your codebase maintainable by eliminating both unnecessary and duplicated code: 1. **Remove debugging artifacts...
PEP 257 docstring compliance
Unstructured-IO/unstructuredAll public modules, classes, methods, and functions must have docstrings that follow PEP 257 formatting standards. Th...
explicit None handling
Unstructured-IO/unstructuredAlways handle potential None values explicitly through defensive programming patterns, proper type annotations, and e...
Minimize allocation hotspots
spring-projects/spring-frameworkReduce object creation in performance-critical paths by carefully evaluating allocation patterns. For frequently inst...
Improve code organization
sgl-project/sglangPrioritize clean code structure and readability in AI/ML codebases by avoiding inline conditionals, using descriptive...
optimize algorithmic complexity
servo/servoPrioritize algorithmic efficiency by choosing operations and data structures that minimize computational complexity. ...
comprehensive API documentation
servo/servoAll public items, struct fields, and methods must have comprehensive documentation. When implementing web specificati...
Split for better readability
getsentry/sentry-phpBreak long lines and complex structures across multiple lines to improve code readability. Follow these guidelines: ...
require module documentation
semgrep/semgrepAll modules containing functions should have corresponding .mli files with comprehensive documentation. The .mli file...
Optimize for readability
dotnet/runtimeWrite code that clearly communicates intent by using appropriate naming and formatting techniques. Improve readabilit...
Device-agnostic acceleration code
pytorch/pytorchAvoid hardcoding specific device types like 'cuda' in AI code. Instead, use device-agnostic approaches such as device...
maintain code consistency
emcie-co/parlantEnsure consistent patterns, formatting, and conventions throughout the codebase. Inconsistencies in code style create...
Craft actionable errors
opentofu/opentofuCreate error messages that provide precise context, avoid unnecessary details, and give users clear actions to take. ...
precise language usage
nuxt/nuxtUse precise, natural language in documentation to improve clarity and readability. Focus on accurate word choice, pro...
Idempotent error-safe disposers
nodejs/nodeWhen implementing resource cleanup logic, especially disposers for explicit resource management, always design for re...
Follow modern C++ guidelines
maplibre/maplibre-nativeAdhere to the C++ Core Guidelines for improved code quality, readability, and maintainability. Follow these key pract...
consolidate algorithmic patterns
ggml-org/llama.cppAvoid duplicating similar algorithmic logic across multiple functions by consolidating them into generic, templated, ...
AI model data validation
BerriAI/litellmAll AI model configuration parameters must be verified against official provider documentation before merging. This i...
Organize documentation content
langflow-ai/langflowStructure documentation to prevent information overload and improve readability by using appropriate organizational e...
Use semantically clear names
kubernetes/kubernetesChoose names that accurately reflect the actual functionality, purpose, or semantic meaning rather than using generic...
Feature gate field preservation
kubernetes/kubernetesWhen implementing feature-gated fields, always preserve existing field values when the feature gate is disabled, but ...
Names express clear intent
JetBrains/kotlinChoose names that clearly express intent and follow established conventions. Prefer explicit, descriptive names over ...
comprehensive test coverage
apache/kafkaEnsure tests cover not only the happy path but also edge cases, error scenarios, and complete workflows. Many code re...
consistent command flag design
jj-vcs/jjDesign command-line interfaces with consistent flag semantics and leverage framework features for validation. Avoid a...
Sanitize all inputs
elie222/inbox-zeroProperly sanitize or escape all user-provided inputs before using them in sensitive contexts to prevent injection att...
explicit error handling
juspay/hyperswitchAvoid catch-all patterns and implicit error handling. Handle each error case explicitly, use the ? operator for error...
Use descriptive naming
duckdb/duckdbChoose names that clearly communicate intent and purpose rather than being generic, abbreviated, or potentially misle...
Use descriptive names
duckdb/duckdbNames should be descriptive and unambiguous, clearly communicating their purpose and intent. Avoid abbreviations and ...
Use descriptive names
stanfordnlp/dspyChoose variable, method, class, and parameter names that clearly communicate their purpose and avoid ambiguity. Names...
Mock external dependencies only
home-assistant/coreWhen writing tests for Home Assistant integrations, mock external library dependencies rather than Home Assistant int...
Use descriptive semantic names
ClickHouse/ClickHouseNames should accurately reflect their purpose, behavior, and semantic meaning to avoid confusion and improve code rea...
Avoid unnecessary allocations
ClickHouse/ClickHouseMinimize memory allocations, data copying, and expensive operations by implementing early exits, using move semantics...
Add explanatory comments
bazelbuild/bazelAdd explanatory comments and documentation for complex logic, non-obvious code behavior, method parameters, and API f...
Standardize platform-agnostic configuration
zed-industries/zedEnsure configuration handling is consistent and platform-agnostic by following these guidelines: 1. Use environment ...
prioritize code clarity
cloudflare/workerdWrite code that prioritizes readability and clarity over minor optimizations or clever shortcuts. When faced with cho...
Validate nullability with types
microsoft/vscodeAlways handle null and undefined values explicitly through proper type declarations and validation patterns rather th...
Document code thoroughly
vllm-project/vllmAlways include comprehensive documentation for your code through both docstrings and explanatory comments. For clas...
Improve code clarity
vlang/vWrite code that clearly expresses intent through explicit patterns, simplified logic, and readable structure. Avoid u...
prioritize code clarity
unionlabs/unionWrite code that prioritizes readability and explicitness over brevity. This includes using explicit type conversions ...
Configuration documentation clarity
astral-sh/tyConfiguration documentation should be precise, specific, and include helpful context for users. Avoid vague or ambigu...
Use proper types
tensorflow/tensorflowMaintain code clarity by using appropriate type declarations and parameter passing conventions: 1. **Prefer explicit...
Organize code by functionality
gravitational/teleportStructure code based on what it does rather than how it's implemented. Group related functionality together, extract ...
Complete API documentation
spring-projects/spring-frameworkDocumentation should be complete, accurate, and follow Spring Framework conventions. Ensure your Javadocs include: 1...
Purposeful documentation standards
getsentry/sentry-phpDocumentation should convey purpose and behavior, not just replicate code structure. Each docblock should explain wha...
Standardize configuration paths
quarkusio/quarkusFollow consistent patterns for storing and referencing configuration files across projects. Place custom configuratio...
Next.js directory structure
prowler-cloud/prowlerKeep the Next.js `/app` directory strictly for routing purposes as per framework conventions. Non-routing related cod...
simplify complex algorithms
prometheus/prometheusWhen implementing algorithms, prioritize simplicity and maintainability over premature optimization. Complex algorith...
Safe null handling
pola-rs/polarsAlways implement robust null handling patterns to prevent unexpected behavior and crashes. Consider all edge cases wh...
Extract duplicated code
pola-rs/polarsIdentify and extract duplicated code into reusable functions or move common fields to parent structures. This makes t...
prefer simple readable code
python-poetry/poetryWrite code that prioritizes clarity and simplicity over cleverness. This improves maintainability and reduces cogniti...
Use descriptive identifier names
microsoft/playwrightChoose specific, descriptive names for variables, methods, types, and other identifiers that clearly communicate thei...
Consistent descriptive naming
opencv/opencvUse clear, descriptive names that follow consistent patterns established in the codebase and broader programming stan...
configuration resolution patterns
nuxt/nuxtWhen defining configuration schemas, use consistent patterns for safe property access, async resolution, and default ...
type-safe database operations
rocicorp/monoImplement proper type conversion and validation when working with different database systems to prevent runtime error...
Avoid unnecessary auto
llvm/llvm-projectUse explicit types instead of `auto` unless the type is obvious from the right-hand side of the assignment or impossi...
TypeScript naming standards
langchain-ai/langchainjsFollow consistent naming conventions in TypeScript to improve code clarity, type safety, and developer experience: 1...
simplify code structure
kubernetes/kubernetesPrioritize code simplification by removing unnecessary complexity, avoiding duplication, and leveraging existing util...
Define technical terms clearly
jj-vcs/jjAlways define technical terms and concepts explicitly in documentation rather than assuming reader knowledge. Avoid a...
Handle errors with care
elie222/inbox-zeroAlways implement comprehensive error handling for asynchronous operations, external API calls, and database operation...
Minimize allocations and syscalls
helix-editor/helixOptimize performance by minimizing unnecessary memory allocations and system calls. Key practices: 1. Avoid unnecess...
AI model integration patterns
google-gemini/gemini-cliWhen integrating with AI models and LLMs, structure your code to properly handle model responses, separate concerns b...
Optimize for code readability
laravel/frameworkPrioritize code readability over clever solutions by: 1. Using early returns to reduce nesting 2. Leveraging modern P...
optimize algorithmic efficiency
electron/electronChoose efficient data structures and algorithms to minimize computational overhead and improve performance. This invo...
Use descriptive names
langgenius/difyChoose names that clearly describe the purpose, behavior, or content of variables, methods, and classes. Avoid ambigu...
Safe null handling
langgenius/difyHandle null and undefined values safely by using appropriate fallback patterns, validating critical parameters early,...
organize code structure
denoland/denoMaintain clean code organization by moving implementation details to appropriate locations, extracting reusable funct...
Centralize dependency management
deeplearning4j/deeplearning4jManage dependencies at the top level using `
Graceful error handling
snyk/cliImplement robust error handling that provides fallback mechanisms, ensures proper resource cleanup, and delivers user...
Restrict public access
bridgecrewio/checkovCloud resources should be configured to restrict public network access by default to minimize potential attack surfac...
Extract focused functions
bridgecrewio/checkovBreak down complex logic into small, well-named functions that each do one thing well. This improves code readability...
Consistent naming conventions
bridgecrewio/checkovMaintain consistent naming patterns throughout the codebase to improve readability and reduce confusion: 1. **Use de...
Prefer explicit nil handling
Homebrew/brewHandle nil values explicitly and consistently to improve code clarity and type safety. Follow these guidelines: 1. U...
consistent configuration handling
better-auth/better-authEnsure configuration options are handled uniformly across all API endpoints and providers. Configuration should have ...
Type-safe flexible APIs
tokio-rs/axumDesign APIs that favor both type safety and flexibility. Use strongly typed wrappers instead of primitive types, but ...
Validate environment variables
appwrite/appwriteAlways validate environment variables before use and implement proper fallback strategies. For required variables, fa...
Handle errors gracefully always
appwrite/appwriteAlways implement graceful error handling for resource lookups, data parsing, and system operations. Catch specific ex...
Enforce API endpoint consistency
appwrite/appwriteWhen implementing or modifying API endpoints, ensure consistency across related routes by checking: 1. Parameter nam...
optimize algorithmic efficiency
alacritty/alacrittyEliminate unnecessary operations and choose appropriate data structures to improve algorithmic efficiency. Look for o...
Consistent semantic naming
vercel/aiUse clear, consistent, and semantic naming patterns across your codebase to improve readability and maintainability: ...
Prefer idiomatic Option handling
zed-industries/zedWhen handling null values in Rust, use idiomatic Option patterns instead of verbose nested conditionals. This improve...
Eliminate unnecessary code patterns
microsoft/vscodeRemove redundant code patterns that add complexity without value. This includes: 1. Duplicate code blocks - Extract ...
Extract reusable functions
volcano-sh/volcanoWhen you identify duplicate code blocks, complex logic that can be simplified, or functionality that doesn't belong i...
Avoid magic numbers
vllm-project/vllmReplace hardcoded values and magic numbers in AI model code with named constants or configuration parameters. This im...
Write clear test cases
Unstructured-IO/unstructuredStructure test cases for maximum readability and maintainability by following these principles: 1. Organize each tes...
validate configuration defaults
Unstructured-IO/unstructuredConfiguration parameters should be properly validated with appropriate defaults and clear handling of edge cases. Avo...
Use descriptive specific names
twentyhq/twentyNames should be descriptive and specific enough to clearly communicate their purpose and avoid confusion. This includ...
Propagate errors with context
vercel/turborepoProperly propagate errors to callers with sufficient context rather than handling them prematurely or hiding them. Le...
Release locks before waking
tokio-rs/tokioIn concurrent systems, it's critical to release locks before performing operations that might trigger reentrancy or b...
Use consistent error handling
tensorflow/tensorflowApply standardized error handling patterns across your codebase for improved reliability and debugging. For new code,...
Use descriptive names
gravitational/teleportChoose names that clearly indicate their purpose and behavior rather than using generic or ambiguous terms. Avoid int...
thoughtful configuration design
gravitational/teleportWhen designing configuration schemas and fields, carefully consider their placement, validation, and long-term implic...
use modern null-safe operators
sveltejs/sveltePrefer modern JavaScript null-safe operators over verbose conditional checks to improve code readability and prevent ...
prefer simple code patterns
sveltejs/svelteChoose straightforward, readable code patterns over complex or clever alternatives. This improves maintainability and...
Configurable model selection
browserbase/stagehandAvoid hard-coding model names and provider-specific configurations throughout the codebase. Instead, implement flexib...
Preserve API compatibility
spring-projects/spring-bootWhen evolving APIs, maintain backward compatibility to avoid breaking client code. Consider these guidelines: 1. **A...
avoid unwrap and panic
servo/servoReplace `.unwrap()` and `panic!()` calls with proper error handling to prevent crashes and improve robustness. When e...
API design patterns
servo/servoDesign APIs with appropriate parameter types, place conversion functions as trait implementations in the correct modu...
consistent async/await usage
serverless/serverlessWhen refactoring code to use async/await, ensure complete and consistent adoption throughout the function or module. ...
Descriptive identifier naming
getsentry/sentry-phpChoose meaningful, self-explanatory names for variables, parameters, properties, and methods that clearly convey thei...
Use descriptive names
semgrep/semgrepNames should clearly and accurately describe their purpose, avoiding abbreviations, acronyms, and misleading terms. T...
prefer simple readable code
semgrep/semgrepChoose clarity and simplicity over clever or complex constructs. Avoid unnecessary abstractions, complex function com...
avoid failwith patterns
semgrep/semgrepAvoid using `failwith`, `assert false`, and similar blunt error handling mechanisms that can turn recoverable errors ...
Keep documentation purposefully minimal
rust-lang/rustDocumentation should be concise, focused, and maintainable. Follow these principles: 1. Keep examples short and demo...
Specific exceptions with context
dotnet/runtimeAlways throw the most specific exception type appropriate for the error condition and include contextual information ...
Optimize memory access
dotnet/runtimeWhen implementing performance-critical algorithms, carefully consider memory access patterns. Document alignment assu...
Follow naming patterns
dotnet/runtimeMaintain consistent naming patterns throughout your code to improve readability and maintainability. Follow these gui...
prefer Kotlin idioms
facebook/react-nativeUse Kotlin-specific constructs and syntax patterns instead of Java-style code to improve readability and maintainabil...
Self-documenting identifier names
rails/railsUse clear, self-documenting names for variables, methods, and classes that express intent without exposing unnecessar...
Layer security defenses
rails/railsImplement multiple layers of security throughout your application rather than relying on a single protection mechanis...
Verify token security level
quarkusio/quarkusWhen refreshing or updating authentication tokens, always verify the new token maintains or exceeds the original toke...
minimize memory allocations
prometheus/prometheusPrioritize memory allocation minimization through buffer reuse, pre-allocation, and efficient data structures. Alloca...
refactor complex conditions
prettier/prettierBreak down complex inline conditions and nested logic into separate, well-named functions or simpler expressions to i...
Use descriptive names
PostHog/posthogChoose names that clearly communicate purpose and accurately represent what they describe. Avoid ambiguous or mislead...
Appropriate error handling
pola-rs/polarsDistinguish between implementation errors (invariant violations) and expected failure cases. For implementation error...
explicit configuration specification
python-poetry/poetryAlways explicitly specify configuration values rather than relying on defaults or implicit behavior. Poetry requires ...
Use semantically accurate names
commaai/openpilotVariable, method, and class names should accurately reflect their actual behavior and purpose. Misleading or vague na...
Prefer explicit readable code
commaai/openpilotWrite code that prioritizes readability and explicitness over cleverness or brevity. This includes several key practi...
Semantic over generic names
netty/nettyChoose specific, descriptive names that clearly convey purpose over generic or abbreviated identifiers. Names should ...
Document public APIs
netty/nettyAll public-facing APIs must be thoroughly documented with clear javadocs. This includes: 1. **Classes and interfaces...
Explicit default configurations
nestjs/nestAlways provide explicit default values for configuration options to improve code readability and maintainability. Use...
Choose meaningful identifier names
nestjs/nestNames for variables, methods, and classes should be descriptive, semantically accurate, and consistent with establish...
Vue component test requirement
n8n-io/n8nEvery Vue component (.vue file) that is created or modified must have at least one corresponding unit test file. The ...
Use descriptive specific names
mastodon/mastodonChoose descriptive, specific names that clearly communicate intent and behavior rather than generic or ambiguous alte...
Ensure semantic naming accuracy
logseq/logseqNames should accurately reflect the actual behavior, purpose, and scope of functions, variables, and classes. Mislead...
Use descriptive consistent names
LMCache/LMCacheChoose names that clearly convey their purpose, role, and meaning while maintaining consistency with established patt...
Safe access patterns
BerriAI/litellmAlways use safe access methods when working with potentially null or undefined values. Use .get() for dictionary acce...
AI provider documentation completeness
BerriAI/litellmEnsure comprehensive documentation for AI/ML provider integrations that covers all usage patterns, uses precise termi...
Sync documentation with code
langfuse/langfuseAlways ensure documentation and comments accurately reflect the actual code implementation. When modifying code, upda...
API documentation completeness
langflow-ai/langflowEnsure API documentation provides comprehensive, accurate information including limitations, complete workflow exampl...
Use semantically accurate names
apache/kafkaChoose names that accurately reflect the purpose, scope, and semantics of variables, methods, and classes. Names shou...
eliminate redundant code
jj-vcs/jjRemove unnecessary code, operations, and annotations that don't add value. This includes redundant type annotations w...
Simplify code structure
istio/istioPrioritize code simplicity and readability by leveraging standard library functions, improving control flow patterns,...
Add explanatory comments
istio/istioCode should include explanatory comments that help future maintainers understand complex logic, design decisions, fie...
Use transactions for consistency
elie222/inbox-zeroAlways wrap multiple related database operations in a transaction to ensure data consistency and prevent partial upda...
Remove commented code
elie222/inbox-zeroCommented-out code should be removed from the codebase rather than left as comments. Keeping commented code: 1. Clut...
Extract repeated code
grafana/grafanaIdentify and extract repeated code patterns into well-named functions to improve readability, maintainability, and te...
eliminate code duplication
block/gooseActively identify and eliminate code duplication by extracting repeated logic into reusable functions, using loops in...
Code structure clarity
ghostty-org/ghosttyWrite code with clear structural organization that enhances readability and maintainability. Extract duplicated or co...
organize code by responsibility
google-gemini/gemini-cliPlace code at the appropriate abstraction level and extract complex logic to dedicated modules. Large files like App....
Explicit null handling
laravel/frameworkUse explicit identity comparisons for null checks and leverage modern PHP null-handling features to create more relia...
minimize memory allocations
gofiber/fiberPrioritize reducing memory allocations and choosing efficient data structures to improve performance. Avoid unnecessa...
Ensure comprehensive test coverage
gofiber/fiberAll code paths, error conditions, and edge cases must have corresponding unit tests to ensure robust functionality an...
Documentation translation guidelines
fastapi/fastapiMaintain consistency and accuracy when translating documentation. Ensure technical terms and special formatting eleme...
conditional feature initialization
electron/electronOnly initialize configuration-dependent features, systems, or resources when the relevant settings, flags, or conditi...
Name reflects meaning
elastic/elasticsearchChoose names that clearly communicate the intent, behavior, and semantics of code elements. Names should be accurate,...
Eliminate code duplication
duckdb/duckdbActively identify and eliminate code duplication to improve maintainability and reduce the risk of inconsistent behav...
avoid silent failures
stanfordnlp/dspyAlways provide clear feedback when operations fail, even when continuing with fallbacks or alternative approaches. Si...
Use modern null handling
discourse/discourseLeverage modern JavaScript operators and patterns for cleaner, more robust null and undefined handling. This improves...
minimize memory allocations
denoland/denoIdentify and eliminate unnecessary memory allocations in performance-critical code paths. This includes pre-allocatin...
Remove debugging artifacts
deeplearning4j/deeplearning4jProduction code should be free from debugging artifacts that reduce readability and maintainability. Remove all debug...
Extract repeated logic
comfyanonymous/ComfyUIWhen you notice code patterns being repeated across functions or methods, extract the common logic into separate, reu...
Use descriptive names
snyk/cliChoose names that clearly communicate purpose, content, and intent. Avoid generic or ambiguous identifiers that requi...
Fail gracefully always
chef/chefEnsure code handles errors robustly by using protective patterns that prevent resource leaks, provide clear diagnosti...
Centralize environment variables
bridgecrewio/checkovAll environment variables should be defined in a centralized location (`checkov/common/util/env_vars_config.py`) rath...
Authorization hierarchy verification
calcom/cal.comAlways implement comprehensive authorization checks that verify user permissions at the appropriate hierarchy level (...
Ensure comprehensive test coverage
bazelbuild/bazelWhen implementing new functionality or modifying existing code, always add corresponding tests that comprehensively c...
Documentation quality standards
Azure/azure-sdk-for-netEnsure documentation is specific, complete, and actionable for developers: 1. **Provide meaningful content** - Avoid...
Axum Code Review: Interaction Patterns
tokio-rs/axumWhen implementing Axum-based applications, it is crucial to ensure that the interaction patterns between components a...
Ensure database transactional integrity
appwrite/appwriteWhen performing multiple related database operations, use transactions and proper error handling to maintain data con...
comprehensive test coverage
angular/angularEnsure test suites provide comprehensive coverage by including edge cases, different input scenarios, and all code pa...
Use descriptive names
cloudflare/workers-sdkChoose names that clearly describe their purpose, behavior, and data type rather than generic or ambiguous alternativ...
Informative error messages
cloudflare/workers-sdkError messages should provide specific context and actionable guidance to help developers understand and resolve issu...
dependency version constraints
cloudflare/workers-sdkEnsure consistent and appropriate dependency version constraints across all package.json files. Use flexible version ...
Use appropriate exception types
cloudflare/workerdChoose the correct exception handling mechanism and type based on the error condition's nature and audience. Use JSG_...
Prioritize descriptive naming
cloudflare/workerdChoose clear, self-explanatory names that prioritize readability over brevity. Avoid abbreviations, obscure identifie...
isolate lock safety
cloudflare/workerdAlways ensure proper isolate lock management and thread-safe access patterns when working with JavaScript contexts an...
Vectorize over Python loops
vllm-project/vllmReplace Python loops and list comprehensions with vectorized operations when processing tensors or performing repeate...
Catch specific exception types
vllm-project/vllmAvoid using broad exception handlers like `except Exception:` or bare `except:`. Instead, catch specific exception ty...
Prevent concurrent access races
vitessio/vitessWhen sharing data across goroutines, always use proper synchronization mechanisms to prevent race conditions. Race co...
Meaningful consistent naming
vitessio/vitessUse descriptive, semantically clear names that follow consistent patterns throughout the codebase. Names should conve...
Names should be descriptive
astral-sh/uvUse clear, descriptive names while avoiding redundant qualifiers. Choose full words over abbreviations unless the abb...
Clear precise documentation
astral-sh/uvDocumentation should use direct, precise language that accurately describes components and their behavior. Maintain c...
Use descriptive semantic names
unionlabs/unionChoose names that clearly communicate purpose, intent, and functionality rather than generic or abbreviated alternati...
Optimize critical loops
microsoft/typescriptWhen implementing algorithms with nested loops or recursive operations, carefully analyze the computational complexit...
simplify code structure
twentyhq/twentyWrite code that is easy to read and understand by avoiding unnecessary complexity in structure and logic. This includ...
Validate configurations comprehensively
vercel/turborepoWhen implementing configuration systems, ensure comprehensive validation, testing, and documentation. Key requirement...
Descriptive, unambiguous identifiers
vercel/turborepoChoose names that clearly express intent and behavior while avoiding ambiguity. Identifiers should communicate their ...
ensure documentation completeness
traefik/traefikDocumentation should include all necessary information for users to successfully implement features. This includes pr...
Write focused single-purpose tests
tokio-rs/tokioBreak down large test cases into smaller, focused tests that each verify a single feature or behavior. Each test shou...
Optimize algorithmic complexity
tokio-rs/tokioAlways consider the time and space complexity implications of your code. Choose data structures and algorithms that m...
Return results not panics
huggingface/tokenizersLibraries should never panic as this can crash applications using the library. Always return a `Result` type rather t...
Use descriptive identifiers
microsoft/terminalChoose clear, self-documenting names for variables, methods, parameters, and properties that explicitly convey their ...
optimize algorithmic choices
microsoft/terminalChoose efficient algorithms and data structures to improve performance and reduce computational overhead. This involv...
Cache expensive computations
microsoft/terminalIdentify and cache the results of expensive operations that are computed repeatedly with the same inputs. This includ...
Names reflect precise behavior
temporalio/temporalChoose names that accurately reflect the behavior and purpose of code elements. Names should be semantically precise ...
Descriptive specific names
spring-projects/spring-frameworkChoose names that are specific, descriptive, and accurately reflect the purpose and domain of variables, methods, cla...
Optimize test case design
spring-projects/spring-bootWrite focused, efficient tests that validate core functionality without unnecessary complexity. Key principles: 1. T...
Follow consistent style conventions
spring-projects/spring-bootSpring Boot projects maintain specific coding style conventions for consistency and readability. When contributing co...
Explicit security configurations
spring-projects/spring-bootWhen configuring security-related features, always use the most specific configurer classes to make security decision...
Eliminate redundant operations
sgl-project/sglangAvoid duplicate function calls, repeated tensor operations, and redundant computations that can significantly impact ...
avoid unsafe unwrapping
servo/servoReplace `.unwrap()` calls and sentinel values with safe null handling patterns to prevent runtime panics and improve ...
avoid unnecessary work
servo/servoIdentify and eliminate computational work that serves no purpose, particularly for inactive, hidden, or irrelevant el...
prefer simple readable patterns
serverless/serverlessChoose simple, readable code patterns over complex alternatives. Avoid unnecessary complexity that doesn't add functi...
maintain backwards compatibility
strands-agents/sdk-pythonWhen modifying public APIs, always preserve backwards compatibility to avoid breaking existing consumers. Public meth...
Precise type narrowing
astral-sh/ruffImplement sound type narrowing algorithms that balance precision with correctness. When narrowing types: 1. For dire...
Use descriptive, conflict-free names
TanStack/routerChoose descriptive names that clearly convey purpose while avoiding conflicts with existing APIs, built-in functions,...
Dependency version specification
TanStack/routerEnsure proper dependency version specification and compatibility management in package.json files. Use explicit versi...
Extract reusable patterns
RooCodeInc/Roo-CodeExtract repetitive or complex code into reusable functions, components, or custom hooks. This improves code organizat...
Organize tests for clarity
rails/railsStructure tests to maximize clarity and maintainability by: 1. Placing related tests together in appropriate test fil...
Optimize numerical precision
pytorch/pytorchWhen implementing AI operations that involve matrix multiplication or neural network components, explicitly support m...
Use configurable default values
prowler-cloud/prowlerMake configuration values flexible and robust by avoiding hardcoded values and providing sensible defaults. This ensu...
Specific exception handling
prowler-cloud/prowlerHandle exceptions with specificity rather than using broad catch-all blocks. Catch specific exception types, provide ...
Write meaningful documentation
prometheus/prometheusDocumentation comments should be accurate, concise, and add genuine value rather than restating obvious code behavior...
metrics registration lifecycle
prometheus/prometheusEnsure proper metrics registration and lifecycle management to maintain observability system stability. Handle metric...
Configuration mutual exclusivity validation
prometheus/prometheusEnsure configuration options that are mutually exclusive are properly validated with clear, actionable error messages...
explicit null handling
prisma/prismaPrefer explicit null and undefined handling over optional or nullable types. When possible, provide default values or...
dependency classification standards
prisma/prismaEnsure proper classification and versioning of package dependencies in package.json files. Dependencies should be cla...
Use descriptive variable names
prettier/prettierChoose variable and function names that clearly communicate their purpose, type, and context. Avoid abbreviations, ov...
Documentation example consistency
prettier/prettierEnsure all code examples and documentation maintain consistent formatting standards, use descriptive variable names, ...
Explicit null handling
python-poetry/poetryUse explicit and clear patterns when handling null/None values to improve code readability and maintainability. Avoid...
API consistency standards
emcie-co/parlantMaintain consistent patterns across all API endpoints, including naming conventions, response structures, HTTP status...
Separate configuration lifecycles
opentofu/opentofuMaintain clear separation between different stages of configuration processing by creating dedicated structures for e...
Log effectively for debugging
opentofu/opentofuAlways include meaningful log messages at appropriate levels to aid in debugging and system monitoring. Follow these ...
Document intent and limitations
opentofu/opentofuClearly document the intended purpose, scope limitations, and design decisions in your code. For all exported types, ...
Follow GoDoc conventions
ollama/ollamaDocument code following Go's official documentation style guide (https://tip.golang.org/doc/comment). All exported fu...
Descriptive balanced naming
ollama/ollamaChoose identifier names that clearly communicate their purpose while maintaining an appropriate balance between brevi...
Use specific assertions
octokit/octokit.netAlways write assertions that verify specific, expected values rather than simple existence or boolean checks. This en...
Document public API elements
octokit/octokit.netEvery public API element (classes, methods, properties, constructors) must have XML documentation comments that clear...
explicit null safety
novuhq/novuAlways perform explicit null and undefined checks before processing values, and use the nullish coalescing operator (...
Complete OpenAPI annotations
novuhq/novuEnsure all API endpoints have complete and accurate OpenAPI annotations to support proper SDK generation and document...
Informative error messages
nodejs/nodeError messages should be specific, actionable, and include context that helps developers understand and fix the issue...
Evolve return values
nodejs/nodeWhen extending APIs with new capabilities, carefully consider how changes to return values affect consumers. Avoid cr...
Technical documentation precision
vercel/next.jsEnsure technical documentation is precise, accurate, and correctly formatted to prevent confusion and improve develop...
Secure Data Handling in Next.js Applications
vercel/next.jsWhen building Next.js applications that handle sensitive data, it's crucial to implement robust security measures to ...
Effective Cache Management in Next.js Applications
vercel/next.jsWhen implementing caching in Next.js applications, it is crucial to be intentional about the caching behavior for eac...
reduce test verbosity
neovim/neovimWrite concise, efficient tests by eliminating repetitive code and combining related test cases. Avoid verbose pattern...
consistent naming conventions
neovim/neovimMaintain consistent naming patterns and terminology across the codebase to reduce cognitive load and improve code cla...
Design domain-specific error types
neondatabase/neonCreate and use domain-specific error types instead of generic errors or anyhow. This improves error handling clarity ...
Use structured logging
n8n-io/n8nAlways use the project's structured logger instead of direct console methods (`console.log`, `console.error`, etc.). ...
Prevent null reference exceptions
n8n-io/n8nAlways use optional chaining and nullish coalescing operators to prevent runtime errors when accessing properties or ...
Technical precision matters
apache/mxnetWhen documenting AI models, frameworks, and optimization techniques, precision in language is as important as precisi...
Validate noexcept guarantees
maplibre/maplibre-nativeOnly mark functions as `noexcept` when you can guarantee they won't throw exceptions under any circumstances. Common ...
Environment variable access
lobehub/lobe-chatUse direct `process.env` access and standardized configuration management instead of custom environment variable wrap...
Use descriptive names
llvm/llvm-projectChoose names that clearly describe the purpose, behavior, and content of functions, variables, and constants. Names s...
maintain naming consistency
ggml-org/llama.cppFollow established naming patterns and conventions consistently throughout the codebase. This includes using consiste...
Extract repeated code
langfuse/langfuseFollow the DRY (Don't Repeat Yourself) principle by extracting repeated code patterns into helper functions, constant...
API field documentation
kubernetes/kubernetesAPI fields must be comprehensively documented with clear behavior specifications, format constraints, and interaction...
Effective API samples
JetBrains/kotlinCreate clear, comprehensive, and properly structured code samples to document API usage. Follow these principles: 1....
Conditional configuration management
kilo-org/kilocodeEnsure configurations are conditional, context-aware, and resilient. Use feature flags to control functionality avail...
prefer modern collection APIs
apache/kafkaUse modern collection creation methods instead of legacy alternatives for improved readability and conciseness. Repla...
Use descriptive names
influxdata/influxdbNames in code should be self-documenting, accurately reflect purpose, and follow consistent conventions. Apply these ...
Promote code clarity
influxdata/influxdbWrite code that prioritizes clarity and maintainability over brevity. This involves several key practices: 1. **Extr...
Minimize critical path allocations
influxdata/influxdbAvoid unnecessary memory allocations in performance-critical code paths. These allocations not only consume memory bu...
Lock with defer unlock
influxdata/influxdbAlways follow the lock-defer-unlock pattern when protecting shared resources with mutexes. Acquire the lock, immediat...
Choose appropriate lock primitives
influxdata/influxdbSelect lock types based on access patterns - prefer RWLock over Mutex for read-heavy operations to enable concurrent ...
Maintain clean code structure
hyprwm/HyprlandKeep code well-organized by separating interface from implementation, managing dependencies properly, and following c...
Protect sensitive data
juspay/hyperswitchWrap all sensitive data fields in Secret<> types to prevent accidental exposure through logs, debug output, serializa...
Documentation clarity and formatting
ghostty-org/ghosttyEnsure documentation is clear, precise, and consistently formatted. Key practices include: 1. **Be explicit and unam...
Prevent concurrent state races
google-gemini/gemini-cliWhen multiple operations can execute concurrently (e.g., multiple keystrokes in the same React event loop, simultaneo...
Use semantic exceptions
laravel/frameworkChoose exception types that accurately reflect the nature of the error. Use `LogicException` for developer errors lik...
Precise type annotations
laravel/frameworkAlways use the most specific and accurate type information possible in PHPDoc comments to improve static analysis, ID...
Follow naming patterns
gofiber/fiberMaintain consistent naming conventions throughout the codebase by following established patterns and avoiding redunda...
Write clear documentation
fastify/fastifyDocumentation should be clear, precise, and self-contained while following established style conventions. When writin...
Isolate configuration concerns
fastapi/fastapiKeep configuration settings separate from application code by using environment variables or dedicated configuration ...
Document all responses
fastapi/fastapiWhen designing APIs, thoroughly document all possible responses your endpoints can return, not just the "happy path" ...
Single source documentation
expressjs/expressMaintain documentation with a single source of truth to prevent inconsistencies and reduce maintenance burden. When i...
Enforce null safety patterns
expressjs/expressImplement comprehensive null safety patterns to prevent runtime errors and ensure predictable behavior. Follow these ...
use optional types safely
electron/electronWhen functions may not return valid values, use `std::optional` or `absl::optional` instead of raw types that could r...
Optimize before implementing
elastic/elasticsearchBefore implementing algorithms, evaluate their efficiency implications, especially for operations that may be execute...
Handle optional dependencies gracefully
stanfordnlp/dspyWhen integrating with external AI libraries, models, or services, handle optional dependencies gracefully to avoid af...
verify authorization explicitly
discourse/discourseAlways perform explicit authorization checks rather than assuming existing security controls are sufficient. Security...
Avoid ambiguous naming
denoland/denoChoose names that clearly convey their purpose and avoid ambiguous identifiers that can be misinterpreted. This appli...
Document API completely
deeplearning4j/deeplearning4jAll public APIs must have comprehensive and clear documentation that helps developers understand functionality withou...
Semantic naming patterns
crewaiinc/crewaiNames should clearly communicate purpose, relationships, and domain context. Choose identifiers that reveal intent an...
Prefer pythonic simplicity
crewaiinc/crewaiUse Python's expressive features to write cleaner, more maintainable code by reducing nesting and improving readabili...
Clear variable naming
home-assistant/coreUse descriptive, unambiguous variable and function names that clearly convey their purpose and avoid conflicts with P...
avoid code duplication
home-assistant/coreCreate reusable components instead of duplicating similar code patterns. When you find yourself writing similar class...
Environment variable validation
docker/composeAlways validate environment variables and provide appropriate fallbacks when using them for configuration. Environmen...
break down large files
cline/clineLarge files with multiple responsibilities should be broken down into focused, single-responsibility modules to impro...
validate before executing operations
ClickHouse/ClickHouseAlways validate inputs and preconditions before executing database operations, and fail explicitly rather than silent...
Use centralized loggers
snyk/cliAlways use centrally supplied loggers from the invocation context or configuration instead of creating new logger ins...
Extract and organize methods
chef/chefBreak down large, complex methods into smaller, focused methods with clear names that describe their purpose. This im...
Write pythonic code
bridgecrewio/checkovEmbrace Python's idiomatic programming style to make your code more readable, concise, and maintainable. Follow these...
Safe dictionary access
bridgecrewio/checkovAlways use safe dictionary access patterns when handling potentially null or missing values. This prevents KeyError a...
Restrict public network
bridgecrewio/checkovAlways configure cloud resources to restrict or disable public network access unless explicitly required for the appl...
Choose optimal algorithms
bridgecrewio/checkovAlways select appropriate data structures and algorithms based on their performance characteristics and the specific ...
Write self-documenting tests
boto/boto3Tests should clearly communicate their purpose and expectations without requiring readers to analyze implementation d...
Wrap errors with context
argoproj/argo-cdWhen propagating errors up the call stack, always wrap them with contextual information about the failing operation u...
Comprehensive migration planning
appwrite/appwriteWhen changing identifier systems (e.g., from using `getInternalId()` to `getSequence()`), implement comprehensive mig...
consistent null handling patterns
angular/angularUse consistent and meaningful null/undefined handling patterns throughout your code. Prefer positive type guards over...
Explain code intent
alacritty/alacrittyComments and documentation should explain WHY code exists and what purpose it serves, not just describe what the code...
Use descriptive action names
apache/airflowNames should clearly indicate purpose and behavior using appropriate action verbs and descriptive terms. This applies...
Test through public APIs
zed-industries/zedWrite comprehensive tests that validate functionality through public interfaces rather than testing implementation de...
Document compatibility flags comprehensively
cloudflare/workerdAll compatibility flags must include comprehensive documentation that clearly explains their purpose, behavior, timin...
comprehensive assertion testing
cloudflare/workerdEnsure test assertions are thorough and complete by testing both expected behavior and error conditions with specific...
Avoid redundant operations
volcano-sh/volcanoEliminate duplicate computations, unnecessary API calls, and redundant processing to improve performance and reduce s...
Add explicit nil checks
volcano-sh/volcanoAlways add explicit nil checks before accessing object properties and after type assertions to prevent null pointer e...
Follow logging best practices
vllm-project/vllmMaintain high-quality logging throughout the codebase by following these best practices: 1. **Use appropriate log le...
Check before access
vllm-project/vllmAlways verify that objects, attributes, and variables are not None before accessing their properties, calling their m...
Dynamic configuration needs validation
vitessio/vitessWhen implementing dynamic configuration options, validate that the system actually supports runtime changes for that ...
Descriptive consistent naming
vitejs/viteChoose variable, function, and class names that accurately reflect their purpose while maintaining consistency with e...
informative error messages
vlang/vError messages should be specific, contextual, and include relevant information to aid debugging and user understandi...
function documentation standards
vlang/vAll public functions and methods must be documented with comments that `v doc` can understand. Documentation should s...
Clear technical writing
vlang/vEnsure technical documentation uses clear, grammatically correct language with consistent formatting when explaining ...
Choose efficient data structures
vlang/vSelect data structures and algorithms based on performance characteristics and actual usage patterns rather than conv...
Structure for readability
astral-sh/uvOrganize code to maximize readability and maintainability. When code becomes complex, break it down into smaller, mor...
Redact URL credentials
astral-sh/uvAlways redact sensitive credentials in URLs before logging, displaying in error messages, or serializing to prevent a...
Choose efficient data structures
unionlabs/unionSelect data structures and algorithms that optimize for the specific use case rather than defaulting to generic colle...
Organize tailwind classes
shadcn-ui/uiStructure your Tailwind CSS classes for readability and maintainability. Instead of long chains of conditional classe...
Names reveal semantic purpose
microsoft/typescriptChoose names that clearly communicate the semantic purpose and behavior of code elements. Variable and function names...
Document function behavior completely
microsoft/typescriptFunctions should be documented with comprehensive JSDoc comments that cover: 1. Purpose and behavior description 2. A...
prefer compile-time configuration
tree-sitter/tree-sitterUse compile-time configuration checks with `cfg!` macros instead of runtime environment variable parsing when the con...
avoid unnecessary Option operations
tree-sitter/tree-sitterWhen working with Option types, prefer efficient and safe access patterns over unnecessary operations. Use `.as_ref()...
Use descriptive names
traefik/traefikChoose names that clearly express the purpose, behavior, or semantic meaning of variables, functions, and types. Avoi...
Structure conditional compilation
tokio-rs/tokioUse organized structural patterns for conditional compilation to improve code maintainability and readability. Avoid ...
Follow naming conventions
tokio-rs/tokioChoose names that follow established API conventions and guidelines to create a consistent, intuitive codebase: 1. F...
Meaningful consistent names
tensorflow/tensorflowChoose names that are both semantically precise and follow consistent conventions. Names should accurately reflect be...
Measure performance impact
sveltejs/svelteBefore making performance-related changes, measure the actual impact with benchmarks and profiling. Many performance ...
Document structure consistency
supabase/supabaseMaintain consistent document structure and formatting in documentation to improve readability and user experience. Fo...
Use AssertJ correctly
spring-projects/spring-frameworkSpring Framework tests must use AssertJ for assertions rather than JUnit's `Assertions`, Spring's `Assert` class, or ...
Maintain consistent naming patterns
spring-projects/spring-bootFollow established naming patterns and conventions throughout the codebase to ensure consistency and clarity. This in...
Consistent observability data
spring-projects/spring-bootWhen implementing observability features, always ensure consistency in your data model, especially with tags and attr...
Simplify conditional structures
apache/sparkOrganize complex conditional logic using clear, sequential patterns rather than nested structures or multiple early r...
validate memory bounds
bytedance/sonicAlways validate array and string bounds before accessing memory to prevent out-of-bounds access and potential crashes...
Package organization standards
SigNoz/signozMaintain proper package organization by following established structural patterns and separation of concerns. Code sh...
Promise error handling patterns
serverless/serverlessWhen handling promise errors, use the second callback parameter of `.then()` instead of `.catch()` when you want to h...
Eliminate redundant operations
serverless/serverlessIdentify and eliminate repeated expensive operations to improve performance. Look for opportunities to cache results,...
API schema validation accuracy
serverless/serverlessEnsure that JSON schema validation for API configurations precisely matches the actual service requirements and const...
Language-agnostic configuration design
oraios/serenaDesign configuration parameters to be language-agnostic when possible, use established configuration objects, and mai...
Use data providers effectively
getsentry/sentry-phpOrganize your test suite by using data providers to consolidate similar test cases rather than creating multiple test...
Evolve API safely
getsentry/sentry-phpWhen modifying existing APIs, implement changes that maintain backward compatibility while enabling new functionality...
Minimize mocks verify behavior
getsentry/sentryWrite tests that verify actual system behavior rather than implementation details by minimizing mock usage and focusi...
eliminate code duplication
strands-agents/sdk-pythonIdentify and consolidate duplicate code patterns by extracting common logic into reusable functions and unifying simi...
Choose appropriate synchronization
strands-agents/sdk-pythonSelect the correct synchronization mechanism based on your execution context and avoid unnecessary synchronization ov...
Standardize configuration value handling
rust-lang/rustImplement robust and type-safe configuration handling to avoid fragile hardcoding and improve maintainability. Key gu...
Ensure complete test coverage
rust-lang/rustWrite comprehensive tests that cover all relevant cases and variations while maintaining proper organization and stru...
Simplify code expressions
dotnet/runtimeStrive for clarity by simplifying code expressions and reducing unnecessary complexity. Complex or verbose expression...
Choose error strategies deliberately
astral-sh/ruffMake deliberate choices about error handling strategies based on the context. Decide between early returns with appro...
SSR documentation completeness
TanStack/routerEnsure server-side rendering documentation provides complete implementation details with proper build configurations ...
Validate nullable values explicitly
RooCodeInc/Roo-CodeAlways handle potentially null or undefined values explicitly using type guards, null coalescing operators, and prope...
Preserve error context chain
RooCodeInc/Roo-CodeWhen catching and re-throwing errors, always preserve the original error context using the `cause` option of the Erro...
Maintain consistent terminology patterns
RooCodeInc/Roo-CodeEnsure consistent terminology usage across the codebase, especially in localization files and technical documentation...
Document i18n string usage
RooCodeInc/Roo-CodeAll user-facing strings must be documented with translation function usage to ensure proper internationalization supp...
Consistent localization formatting
RooCodeInc/Roo-CodeEnsure all localization strings maintain consistent formatting patterns within each locale file. This includes: 1. *...
Configure with care
RooCodeInc/Roo-CodeAlways validate configuration values before use, provide sensible defaults, and centralize constants in shared module...
simplify redundant logic
facebook/react-nativeEliminate redundant conditional logic, extract duplicated code, and choose simpler patterns over complex implementati...
extract complex logic
facebook/react-nativeBreak down complex functions and large files into smaller, focused units with clear responsibilities. Extract complex...
Configuration validation and defaults
facebook/react-nativeAlways validate configuration structure before accessing properties and provide sensible defaults while preserving ex...
avoid !! operator
facebook/react-nativeAvoid using the not-null assertion operator (`!!`) as it can cause runtime crashes if the assumption about non-nullab...
Database-specific query optimization
rails/railsLeverage database-specific features to optimize queries and improve performance. Different database engines have uniq...
Configure at proper scope
rails/railsPlace configuration options at their proper scope within the framework hierarchy. Avoid tight coupling between compon...
Meaningful error communication
quarkusio/quarkusError handling should be designed to provide clear, actionable information to developers while avoiding redundancy. F...
Document configuration comprehensively
quarkusio/quarkusConfiguration properties should be thoroughly documented with explicit details about constraints, units, default valu...
API evolution strategy
quarkusio/quarkusDesign APIs with future extensibility in mind by using parameter objects instead of direct method parameters. When an...
Document code rationale
pydantic/pydanticAdd clear comments that explain the "why" behind non-obvious code decisions, complex logic, or special-case handling....
Consistent term capitalization
pydantic/pydanticFollow consistent capitalization rules for technical terms, acronyms, and library names throughout your codebase and ...
Meaningful consistent naming
prowler-cloud/prowlerUse names that clearly describe the purpose and behavior of variables, methods, classes, and files, while maintaining...
Extract duplicate code
prisma/prismaWhen you notice code patterns being repeated across multiple locations, extract them into reusable functions or const...
Database provider compatibility
prisma/prismaEnsure database code properly handles provider-specific differences and capabilities. Different database providers ha...
consistent error object usage
prisma/prismaAlways use proper Error objects when throwing exceptions, maintain consistent error handling contracts, and ensure ty...
Consistent clear naming
prisma/prismaUse consistent terminology across similar concepts and choose names that clearly indicate their purpose. Avoid overlo...
Use descriptive names
python-poetry/poetryVariable, method, and class names should clearly and accurately describe their purpose, content, or behavior. Mislead...
optimize algorithmic efficiency
python-poetry/poetryChoose efficient algorithms and data structures to avoid unnecessary computational complexity. Look for opportunities...
dependency constraint consistency
python-poetry/poetryMaintain consistent formatting and rationale for dependency version constraints in configuration files. Use caret not...
validate inputs early
microsoft/playwrightAlways validate function parameters and configuration options at the beginning of functions, providing specific and a...
Specify configuration behaviors
opentofu/opentofuWhen implementing configuration features (variables, flags, resources), thoroughly document their behavior in all sce...
Optimize code location scope
open-telemetry/opentelemetry-pythonPlace code in the most specific and appropriate location to improve findability and maintainability. Follow these pri...
Future-proof API design
open-telemetry/opentelemetry-pythonDesign APIs that can evolve without breaking existing code. Use keyword-only arguments (with `*,`) for optional param...
Use proper assertions
opencv/opencvWrite tests with proper assertions to ensure reliability and maintainability. Follow these guidelines: 1. **Check fo...
Use optimized functions
opencv/opencvWhen implementing algorithms, prefer using OpenCV's built-in optimized functions over writing custom implementations....
Maintain consistent style
octokit/octokit.netFollow established patterns consistently throughout the codebase to improve readability and maintainability: 1. **Us...
User-centric documentation practices
nrwl/nxDocumentation should prioritize user needs and experience over technical convenience. This means using appropriate li...
Avoid code duplication
nrwl/nxBefore implementing new functionality, check if similar utilities or patterns already exist in the codebase. Reuse ex...
Use consistent terminology
nuxt/nuxtPrioritize consistent, clear, and beginner-friendly terminology throughout your codebase and documentation. Choose na...
Version APIs with care
nodejs/nodeWhen introducing new API features or changes, implement proper versioning to maintain stability and backward compatib...
Public over internal APIs
nodejs/nodeWhen designing or implementing APIs, always prefer publicly documented APIs over internal ones. Internal APIs may cha...
Benchmark before optimizing code
nodejs/nodePerformance optimizations should be validated through benchmarks before implementation. This helps prevent premature ...
Simplify control flow
netty/nettyStreamline code by simplifying control flow structures to improve readability. Eliminate unnecessary nesting and verb...
Proper asynchronous error handling
nestjs/nestEnsure errors in asynchronous operations and event-based systems are handled consistently to prevent unexpected behav...
Descriptive identifier names
nestjs/nestChoose identifier names (variables, functions, parameters, classes) that clearly describe their purpose, content, or ...
Complete function documentation
neovim/neovimEnsure all functions have comprehensive, accurate documentation including required tags (@param, @return, @since), cl...
API consistency patterns
neovim/neovimEnsure similar API functions use consistent parameter patterns, types, and behaviors. When designing new APIs or modi...
Structure endpoints for REST
neondatabase/neonOrganize API endpoints hierarchically by resource type and use appropriate HTTP methods based on operation semantics....
Clear consistent identifier names
neondatabase/neonChoose clear, consistent, and non-redundant names for identifiers across the codebase. Follow these guidelines: 1. U...
Maintain test state isolation
n8n-io/n8nEnsure each test runs in isolation by properly managing test state, mocks, and timers. Clean up all test artifacts in...
Simplify for readability
apache/mxnetComplex expressions, especially nested ternary operations, reduce code readability and maintainability. Prefer simple...
Consistent naming patterns
apache/mxnetMaintain consistent naming conventions throughout the codebase to enhance readability and reduce confusion. This appl...
remove unnecessary code
rocicorp/monoEliminate unnecessary code elements that add complexity without providing value. This includes removing redundant fun...
prioritize code readability
rocicorp/monoWrite code that prioritizes clarity and readability over cleverness or brevity. This includes several key practices: ...
centralize configuration management
mastodon/mastodonMigrate configuration from direct environment variable access to Rails' config_for mechanism for better organization,...
Modern C++ style practices
maplibre/maplibre-nativeApply modern C++ features and consistent syntax patterns to improve code readability and safety. Follow these guideli...
Simplify code readability
logseq/logseqWrite code that prioritizes clarity and simplicity over cleverness. Use appropriate Clojure idioms to make code more ...
Extract reusable components
lobehub/lobe-chatExtract utilities, types, constants, and shared logic into dedicated modules to improve code maintainability and redu...
Add unit tests
lobehub/lobe-chatAll new functionality must include corresponding unit tests. This is especially critical for utility functions, core ...
Simplify for readability
LMCache/LMCacheImprove code readability by simplifying complex logic, using Pythonic idioms, and removing unnecessary code. Extract ...
Ensure operation completion safety
LMCache/LMCacheIn concurrent code, ensure that operations complete safely before proceeding to prevent race conditions and data corr...
comprehensive test coverage
llvm/llvm-projectTests should comprehensively cover all relevant scenarios, including return values, edge cases, different compilation...
avoid unnecessary allocations
llvm/llvm-projectMinimize performance overhead by avoiding unnecessary memory allocations, expensive data structures, and redundant ob...
leverage existing framework functionality
ggml-org/llama.cppBefore implementing custom solutions in AI model conversion code, thoroughly investigate whether the framework alread...
eliminate code duplication
ggml-org/llama.cppAvoid duplicating code blocks by extracting common functionality into reusable functions, using templates for type-ge...
Follow consistent naming patterns
BerriAI/litellmMaintain consistent naming conventions across all aspects of the codebase, including file structures, folder organiza...
Surface errors to users
langfuse/langfuseAlways provide user-visible feedback for errors instead of only logging to the console. This ensures users are aware ...
Falsy vs null checks
langfuse/langfuseDistinguish between falsy values (0, '', false, null, undefined) and null/undefined values in your code. Use explicit...
Cache expensive operations
langfuse/langfuseIdentify and cache results of computationally expensive or repetitive operations instead of recalculating them multip...
Use comprehensive JSDoc
langchain-ai/langchainjsAlways use JSDoc format (`/** */`) instead of regular comments (`//`) for documenting classes, functions, and interfa...
Preserve API backward compatibility
langchain-ai/langchainjsWhen modifying existing APIs, maintain backward compatibility by implementing changes in a non-breaking way. Use meth...
implement proper observability
kubernetes/kubernetesEnsure observability mechanisms (events and metrics) are implemented correctly with appropriate types, accurate label...
Clear field documentation
kubernetes/kubernetesWrite precise, unambiguous documentation that explains what fields and methods represent rather than implementation d...
Avoid unnecessary work
kubernetes/kubernetesOptimize performance by avoiding unnecessary computations, allocations, and operations. Use feature gates, lazy evalu...
Simplify code structure
kubeflow/kubeflowStrive to simplify code structure by eliminating unnecessary complexity. This includes: 1. **Move conditions higher ...
Precise workflow triggers
kubeflow/kubeflowConfigure CI/CD workflows to trigger precisely based on relevant file path changes. This minimizes unnecessary builds...
Go export naming conventions
kubeflow/kubeflowIn Go, the first letter of an identifier (function, variable, struct field, etc.) determines its visibility outside t...
Use configuration property providers
JetBrains/kotlinAlways use Gradle's Provider API when accessing project, system, or Gradle properties in your build configuration. Th...
Test edge cases
JetBrains/kotlinEnsure tests verify both basic functionality and edge cases. Tests that only cover the happy path can miss critical b...
Minimize unnecessary work
JetBrains/kotlinOptimize performance by reducing the amount of computation performed, especially on data that won't appear in the fin...
Keep code clearly organized
JetBrains/kotlinMaintain code readability and organization by extracting focused, well-named functions and using appropriate scoping....
Design extensible stable APIs
JetBrains/kotlinWhen designing public APIs, prioritize extensibility while maintaining backward compatibility and implementation hidi...
prioritize documentation clarity
jj-vcs/jjWrite documentation that prioritizes user understanding over technical precision. Avoid unclear phrases, overly techn...
Use testify assertions
influxdata/influxdbAlways use the testify package (require/assert) in tests instead of standard Go testing assertions. The testify libra...
Validate environment variables strictly
elie222/inbox-zeroEnforce strict validation of environment variables using Zod schemas with explicit environment-specific rules. Requir...
prevent null dereferences
hyprwm/HyprlandAlways verify pointers are valid before dereferencing to prevent crashes and undefined behavior. This applies to regu...
avoid expensive hot paths
hyprwm/HyprlandIdentify and optimize expensive operations in frequently executed code paths to prevent performance bottlenecks. Hot ...
API type consistency
juspay/hyperswitchUse structured types instead of generic strings in API definitions to improve type safety and clarity. Prefer enums o...
use descriptive names
helix-editor/helixChoose specific, purpose-revealing names that clearly communicate intent rather than generic, abbreviated, or ambiguo...
Safe concurrent programming
grafana/grafanaWhen working with concurrent code, carefully manage shared resources and synchronization to prevent race conditions, ...
Follow documentation conventions
grafana/grafanaEnsure documentation adheres to established style guidelines and technical standards: 1. **Use proper terminology an...
Test behavioral differences
google-gemini/gemini-cliTests should verify that different states, modes, or inputs produce meaningfully different behaviors, not just that c...
reduce nesting complexity
google-gemini/gemini-cliPrefer early returns, guard clauses, and helper method extraction to reduce nesting levels and improve code readabili...
Use modern PHPUnit attributes
laravel/frameworkPrefer modern PHPUnit attributes over PHPDoc annotations for improved type safety, IDE support, and code readability ...
check all error returns
gofiber/fiberAlways check and handle error returns from function calls, even for operations that seem unlikely to fail. Ignoring e...
Technical term consistency
fastapi/fastapiWhen working with multilingual codebases or documentation, maintain consistent naming conventions for technical terms...
Sync versus async tests
fastapi/fastapiChoose the appropriate testing approach based on your test requirements. For standard API endpoint testing, use `Test...
Standardize dependency version notation
expressjs/expressWhen specifying dependencies in package.json, follow consistent version notation patterns that align with your projec...
Follow StandardJS when modifying
expressjs/expressWhen modifying existing code, update the touched lines to follow StandardJS conventions while preserving the style of...
Clear intention in names
expressjs/expressChoose names that clearly communicate intention and follow established conventions. This applies to variables, functi...
prefer const correctness
electron/electronAlways mark variables, parameters, and methods as `const` when they don't modify state. This improves code safety, en...
comprehensive test coverage
duckdb/duckdbEnsure thorough test coverage by systematically testing edge cases, boundary conditions, failure scenarios, and diffe...
avoid repeated expensive operations
duckdb/duckdbIdentify and eliminate repeated expensive computations, especially in loops and frequently executed code paths. This ...
Complete parameter documentation
stanfordnlp/dspyEnsure all public functions and classes have comprehensive docstrings that include parameter descriptions, type hints...
Use descriptive identifier names
django/djangoChoose clear, descriptive names for variables, functions, and classes that accurately convey their purpose and follow...
Follow established naming conventions
discourse/discourseEnsure all identifiers follow the established naming conventions for the codebase and framework being used. This incl...
Clean code formatting rules
continuedev/continueMaintain consistent and clean code formatting to improve readability and maintainability. Follow these guidelines: 1...
CI script reliability practices
continuedev/continueEnsure CI/CD workflows maintain reliability by following these practices: 1. **Use explicit script paths** - Always ...
explicit configuration management
docker/composeMake all configuration settings explicit and well-documented, avoiding implicit defaults and auto-detection where pos...
semantic naming accuracy
ClickHouse/ClickHouseEnsure that method, variable, and class names accurately reflect their actual behavior, purpose, or content. Names sh...
Explicit error handling
ClickHouse/ClickHouseAlways handle error conditions explicitly rather than silently ignoring them or using generic error responses. Use sp...
Document non-obvious code
ClickHouse/ClickHouseAdd explanatory comments for any code element that is not self-explanatory, including complex return types, method pa...
prevent silent test failures
snyk/cliTests must explicitly fail when expected conditions are not met, rather than silently exiting early or using weak ass...
Handle all errors explicitly
snyk/cliAlways explicitly handle errors rather than assuming they are handled by dependencies or ignoring them. Every functio...
Document intent and reasoning
snyk/cliAdd comments that explain the reasoning, intent, or context behind code decisions, especially for non-obvious logic, ...
API response consistency
snyk/cliEnsure consistent patterns for API response handling, error management, and type safety across all API interactions. ...
Document with examples
chef/chefAlways include comprehensive documentation with clear examples for properties, methods, and code patterns. Documentat...
Consistent descriptive naming patterns
chef/chefUse clear, descriptive names that follow consistent patterns across the codebase. For methods and properties: 1. Use...
Meaningful identifier names
bridgecrewio/checkovChoose descriptive and semantic identifiers that clearly convey purpose, role, and behavior. Avoid vague, generic nam...
Validate nullability explicitly
oven-sh/bunAlways validate null or undefined values before using them to prevent crashes and undefined behavior. When implementi...
Assert before cast
oven-sh/bunAlways validate values before performing unsafe operations like dynamic casting. When a value could be null, zero, or...
Standardize API integration patterns
Homebrew/brewEstablish consistent patterns for API integrations by following these guidelines: 1. Document API endpoint usage spe...
Optimize collection operations
Homebrew/brewUse Ruby's built-in collection methods to write more efficient and readable code. This reduces algorithmic complexity...
Prevent algorithmic pitfalls
boto/boto3Avoid common algorithmic errors that lead to incorrect results or inefficient code by following these practices: 1. ...
Follow naming conventions
boto/boto3Use consistent and appropriate naming conventions based on the context in Python code: 1. **Classes**: Use `CamelCas...
Defensive null value handling
boto/boto3Always handle potential null/None values defensively by: 1. Using `.get()` for dictionary access instead of direct ke...
prefer simple readable code
bazelbuild/bazelFavor simple, readable implementations over complex or overly abstracted solutions. This includes eliminating code du...
prefer simple API designs
bazelbuild/bazelDesign APIs with simple, direct interfaces rather than complex parameter passing patterns or unnecessary indirection....
optimize algorithm choices
bazelbuild/bazelChoose algorithms and data structures that provide both deterministic behavior and optimal performance characteristic...
Executor service lifecycle
bazelbuild/bazelProperly manage executor service lifecycle to prevent resource leaks, deadlocks, and orphaned threads that can cause ...
Configuration clarity standards
bazelbuild/bazelConfiguration options should be designed with clarity, consistency, and user experience as primary concerns. This inc...
Design stable APIs
Azure/azure-sdk-for-netWhen creating or modifying APIs, carefully consider what becomes part of your public API surface to ensure backward c...
Check before dereferencing
Azure/azure-sdk-for-netAlways verify objects are not null before dereferencing them, particularly when using methods that might return null ...
Defensive null checking
aws/aws-sdk-jsAlways perform explicit null/undefined checks before accessing properties or using values that could be null or undef...
Stable dependency version management
appwrite/appwriteAlways use stable, well-defined version constraints in configuration files to ensure reproducible builds and prevent ...
Keep documentation paths current
appwrite/appwriteMaintain accurate and consistent documentation paths, references, and descriptions across the codebase. When terminol...
Consistent placeholder conventions
appwrite/appwriteEnsure all placeholders in localization files follow consistent naming conventions to prevent runtime errors and text...
Use semantic descriptive names
ant-design/ant-designChoose variable, function, and type names that clearly communicate their purpose, source, and context. Names should b...
Prevent component re-mounting
ant-design/ant-designMaintain stable component structure to prevent unnecessary re-mounting and unmounting of child components. Conditiona...
API evolution strategy
ant-design/ant-designWhen evolving APIs, design for extensibility and provide clear migration paths to maintain backward compatibility whi...
Use descriptive names
angular/angularChoose names that clearly and unambiguously describe their purpose rather than being overly generic or technical. Nam...
Document configuration specifics
alacritty/alacrittyWhen documenting configuration options in changelogs, README files, or other user-facing documentation, focus on spec...
Prefer Rust structural patterns
zed-industries/zedUse Rust's structural patterns to write more idiomatic and maintainable code. This includes: 1. Use early returns to...
Consider algorithmic complexity
zed-industries/zedWhen implementing algorithms, be mindful of their computational complexity and choose appropriate data structures for...
prefer higher-level APIs
cloudflare/workerdWhen designing APIs, prefer using higher-level abstractions and established patterns over direct low-level handle man...
Node.js API compatibility
cloudflare/workerdWhen implementing Node.js-compatible APIs, ensure exact behavioral matching with Node.js, including export structures...
minimize memory operations
cloudflare/workerdAvoid unnecessary memory allocations, copies, and inefficient memory usage patterns that can impact performance. This...
maintain consistent patterns
cloudflare/workerdEnsure consistent coding patterns and approaches are used throughout the codebase, even when multiple valid alternati...
Use specific semantic names
microsoft/vscodeChoose specific, descriptive names for identifiers that accurately reflect their purpose and behavior. Avoid generic ...
Keep APIs simple JavaScript-like
microsoft/vscodeDesign APIs to be simple and idiomatic to JavaScript/TypeScript while maintaining proper encapsulation. Avoid complex...
Handle errors with specificity
microsoft/vscodeAlways handle errors specifically and explicitly, avoiding generic catch blocks that mask or ignore errors. Ensure pr...
Algorithm explanation clarity
volcano-sh/volcanoWhen documenting algorithms, provide detailed explanations of the underlying logic with concrete examples and clear p...
Use self-documenting names
vllm-project/vllmVariable, function, and parameter names should accurately reflect their purpose, behavior, and content. Choosing desc...
Stable documentation links
vllm-project/vllmEnsure all documentation links are stable, consistent, and correctly targeted to improve navigation and long-term mai...
Process configurations consistently
vllm-project/vllmEnsure that configuration data is processed consistently and correctly throughout the codebase. This includes: 1. **...
Optimize data structures
vitessio/vitessChoose and implement data structures with careful consideration of algorithmic complexity, memory usage, and Go's spe...
Ensure documentation accuracy
vitejs/viteDocumentation must precisely reflect the current codebase implementation. When documenting features, options, or APIs...
Make errors user actionable
astral-sh/uvError messages should provide clear, actionable information that helps users understand and resolve the problem. Each...
Validate production configurations
unionlabs/unionAlways validate configuration values and ensure production safety by avoiding hardcoded values, implementing proper d...
Module resolution hierarchy
microsoft/typescriptWhen configuring TypeScript projects, establish a clear understanding of module and type resolution hierarchies, espe...
Specify algorithmic scope precisely
astral-sh/tyWhen documenting changes to algorithms, data structures, or computational approaches, explicitly identify the specifi...
Use semantically accurate names
twentyhq/twentyNames should clearly and accurately reflect their actual purpose, functionality, and scope. Avoid misleading terminol...
Use domain-specific exceptions
twentyhq/twentyCreate custom exception classes for each domain/module instead of throwing generic errors or letting applications cra...
simplify API interfaces
twentyhq/twentyKeep API interfaces simple and focused by avoiding unnecessary input wrapping, extracting context parameters appropri...
Know your implicit configurations
vercel/turborepoWhen working with Turborepo, be aware of implicit configurations and special files that affect behavior even when not...
Eliminate code duplication
vercel/turborepoAvoid duplicating logic, patterns, or data across the codebase. When similar code appears in multiple places, extract...
Optimize frequent operations
tree-sitter/tree-sitterIdentify code paths that execute frequently (loops, hot functions, repeated calls) and optimize them by avoiding redu...
Algorithm and data optimization
tree-sitter/tree-sitterChoose efficient algorithms and appropriate data structures based on access patterns and computational requirements. ...
complete observability router options
traefik/traefikWhen documenting router configuration options for any provider (Docker, Consul Catalog, ECS, KV stores, Nomad, etc.),...
Use Option methods idiomatically
tokio-rs/tokioWhen dealing with Optional values, prefer Rust's built-in Option methods over manual null checks. This makes code mor...
Structural configuration approaches
tokio-rs/tokioWhen working with feature flags and conditional compilation, prefer structural approaches over scattered configuratio...
Prefer explicit over concise
tokio-rs/tokioChoose explicit and unambiguous names over concise but unclear ones. When a method, type, or variable has a specific ...
Organize code logically
tokio-rs/tokioGroup related code elements together with a consistent and logical structure. Place stable fields and functionality f...
Optimize memory allocation
tokio-rs/tokioBe deliberate about memory allocation patterns to improve performance. Implement these practices: 1. **Pre-allocate ...
Network API design consistency
tokio-rs/tokioWhen designing networking APIs, maintain consistency with existing interfaces while ensuring proper cross-platform co...
Follow import style
tokio-rs/tokioTokio projects follow specific import conventions for consistency and readability. Adhere to these guidelines: 1. Us...
Flexible consistent API patterns
tokio-rs/tokioDesign APIs with flexibility and consistency by leveraging established patterns and avoiding unnecessary constraints....
Design error handling carefully
tokio-rs/tokioWhen implementing error handling, balance between propagation and recovery. Design error types to preserve context wh...
Simplify for readability
huggingface/tokenizersPrioritize code readability by using simpler and more direct expressions. When possible, return values directly inste...
Descriptive purpose-driven naming
hashicorp/terraformChoose identifiers that accurately describe their purpose and behavior, not just their type or how they're used. Name...
Contextual null checks
hashicorp/terraformUse type-appropriate null checking strategies based on the context of your data. For primitive values, ensure they ex...
Use established configuration patterns
microsoft/terminalWhen adding new configuration options or settings, leverage existing configuration frameworks and patterns rather tha...
manage object lifetimes carefully
microsoft/terminalEnsure proper object lifetime management in concurrent scenarios to prevent crashes from dangling pointers and premat...
Choose efficient data structures
microsoft/terminalSelect data structures and types that optimize for both memory usage and computational efficiency. Avoid unnecessary ...
Choose efficient implementations
tensorflow/tensorflowWhen implementing algorithms, prioritize both correctness and performance by selecting appropriate data structures, o...
Specific assertion methods
temporalio/temporalUse the most specific and descriptive assertion methods available in your test framework to improve test readability ...
Precompute and cache
temporalio/temporalAvoid performing expensive operations repeatedly, especially in hot code paths. Identify operations such as parsing, ...
Comprehensive function documentation
gravitational/teleportFunctions, methods, and non-trivial constants should include comprehensive documentation that explains their purpose,...
document configuration hierarchies
sveltejs/svelteWhen documenting configuration options, clearly explain all available configuration levels and their precedence order...
Document complex APIs
sveltejs/svelteRequire comprehensive JSDoc documentation for classes, complex functions, and all exported functions to improve codeb...
Choose descriptive names
sveltejs/sveltePrioritize semantic clarity and descriptive naming over brevity or convenience. Avoid esoteric, abbreviated, or ambig...
Prevent hardcoded secrets
supabase/supabaseNever store sensitive information such as API keys, passwords, tokens, or credentials directly in your source code. T...
Use appropriate collections
spring-projects/spring-frameworkChoose the right collection implementation for each algorithmic task to optimize both performance and readability. Us...
Meaningful exception design
spring-projects/spring-bootDesign exceptions to provide clear context, preserve stack traces, and propagate correctly through your system. Key p...
Documentation clarity principles
spring-projects/spring-bootWhen writing technical documentation, adhere to these core principles to ensure clarity and effectiveness: 1. **Use ...
Document configuration properties completely
spring-projects/spring-bootConfiguration properties should be fully documented with clear descriptions, explicit default values, and proper meta...
Concrete bean return types
spring-projects/spring-bootWhen defining `@Bean` methods in Spring configurations, use concrete return types rather than interfaces while using ...
Alphabetical ordering requirement
spring-projects/spring-bootAlways maintain alphabetical ordering for lists of elements including dependencies, modules, configuration entries, a...
optimize data structures
apache/sparkChoose appropriate data structures and algorithms to optimize computational complexity and performance. Consider the ...
use loose equality checks
serverless/serverlessUse loose equality (`== null`) instead of strict equality (`=== null` or `=== undefined`) when checking for both null...
configuration examples accuracy
serverless/serverlessEnsure configuration examples and documentation use current, supported syntax and accurately reflect the actual behav...
avoid local imports
oraios/serenaPlace all import statements at the top of the file as global imports rather than importing modules within functions o...
Use descriptive identifiers
getsentry/sentryChoose variable, parameter, field, and class names that clearly communicate their purpose and context. Favor specific...
Structure logs with context
getsentry/sentryUse structured logging with appropriate context and log levels to maximize the value of log messages. Include relevan...
Explicit null handling
getsentry/sentry-phpAlways be explicit and consistent when handling null values to improve code clarity and prevent subtle bugs. This app...
Feature flag rollouts
getsentry/sentryUse feature flags to gate new functionality for controlled rollouts. This allows for quick enabling/disabling without...
Structure validation algorithms
rust-lang/rustWhen implementing or modifying parsing and validation algorithms, carefully consider both the correctness and user ex...
Clear helpful error messages
rust-lang/rustCreate user-friendly error messages that guide developers toward solutions. Error messages should: 1. Include the pro...
Optimize common paths
dotnet/runtimeDesign algorithms that optimize for the most common execution paths by prioritizing frequent scenarios in conditional...
Model actual hardware costs
dotnet/runtimeBase optimization decisions on accurate hardware cost models rather than outdated assumptions. Modern architectures h...
Document configuration intent
dotnet/runtimeConfiguration settings should be self-documenting with clear intent. When adding temporary workarounds, conditional f...
Handle nulls with Option
astral-sh/ruffUse Rust's Option type and its methods effectively to handle nullable values. This improves code clarity and safety b...
Enhance code clarity
TanStack/routerEnsure all code examples and documentation are as clear and complete as possible for developers. This includes adding...
API parameter design
TanStack/routerDesign API parameters thoughtfully by making them optional when appropriate, avoiding unnecessary required parameters...
Maintain consistent naming patterns
RooCodeInc/Roo-CodeUse consistent naming patterns throughout the codebase. When adding new identifiers, follow existing patterns in simi...
Enforce resource usage limits
RooCodeInc/Roo-CodeImplement explicit resource limits and monitoring to prevent performance degradation and memory issues. This includes...
Enforce API format consistency
RooCodeInc/Roo-CodeMaintain consistent data formats, parameter units, and interface patterns across API implementations. This includes: ...
Use descriptive semantic names
remix-run/react-routerChoose variable, function, and type names that clearly communicate their purpose and context. Prioritize readability ...
precise null type checking
remix-run/react-routerUse precise null and undefined type checking that matches the actual usage context. Distinguish between checking if a...
Hook dependencies stability
remix-run/react-routerEnsure hook dependencies are minimal, stable, and follow React's rules to prevent unnecessary re-renders and maintain...
configuration consistency standards
remix-run/react-routerEnsure configuration options, flags, and environment settings are handled consistently across all commands and module...
configuration compatibility validation
remix-run/react-routerEnsure that code examples and documentation accurately reflect the constraints and requirements of different renderin...
Prefer simpler expressions
rails/railsAlways choose the simplest, most readable way to express your code logic. Unnecessary complexity makes code harder to...
Minimize unnecessary object allocations
rails/railsAvoid creating unnecessary objects, especially in frequently executed code paths. This includes being mindful of impl...
Minimize public API surface
rails/railsDesign APIs with a minimal public surface area by carefully controlling which methods and properties are exposed. Sta...
Follow documentation conventions
rails/railsMaintain consistent formatting and style in all documentation to improve readability and professionalism: 1. **Use p...
Document APIs clearly
rails/railsWhen designing and documenting APIs, prioritize clarity and completeness through concrete examples and accurate param...
Thread-safe state management
quarkusio/quarkusWhen managing state accessed by multiple threads, ensure thread safety through appropriate synchronization mechanisms...
Graceful API evolution
pytorch/pytorchWhen modifying, deprecating, or replacing APIs, ensure a smooth transition experience for developers by following the...
Standardize dependency management
pydantic/pydanticMaintain consistent dependency management practices across CI workflows to ensure reliable builds and tests. Use the ...
Maintain code consistency
pydantic/pydanticEnsure code follows consistent patterns throughout the codebase, even when duplicating code is necessary. When simila...
Least privilege principle
prowler-cloud/prowlerAlways follow the principle of least privilege by granting the minimum permissions necessary for functionality. This ...
improve code readability
prometheus/prometheusStructure code to maximize readability and reduce cognitive load through proper formatting and control flow patterns....
avoid subjective language
prometheus/prometheusAvoid subjective terms, unexplained jargon, and assumptions about user knowledge in documentation. Replace subjective...
Manage output streams carefully
prisma/prismaAlways consider the destination and lifecycle of output streams to prevent protocol interference, data loss, and unex...
Verify optional chaining necessity
prettier/prettierAnalyze whether optional chaining (`?.`) is actually needed based on the surrounding context and prior validations. R...
prefer efficient algorithms
prettier/prettierChoose more efficient algorithmic approaches by leveraging built-in methods and APIs instead of implementing manual s...
Documentation clarity standards
prettier/prettierEnsure documentation is clear, precise, and technically accurate to prevent confusion and build errors. This includes...
consistent spacing patterns
prettier/prettierMaintain consistent spacing patterns around operators, keywords, and interpolation syntax throughout the codebase. Th...
Cache invalidation consistency
PostHog/posthogEnsure comprehensive and consistent cache invalidation patterns across all models that affect cached data. Every mode...
Optimize memory allocation patterns
pola-rs/polarsMinimize memory allocations and optimize allocation patterns to improve performance. Key practices: 1. Pre-allocate ...
Names reveal clear intent
pola-rs/polarsChoose names that clearly communicate intent and context, avoiding ambiguity or confusion. Variable and function name...
Explicit null handling
pola-rs/polarsAlways be explicit and consistent about how null values are handled in operations and documentation. This clarity pre...
Clear actionable error messages
python-poetry/poetryError messages should be user-friendly, readable, and provide actionable guidance for resolution. Avoid exposing tech...
proxy configuration precedence
microsoft/playwrightEnsure proxy configuration follows proper precedence hierarchy and handles different proxy types correctly. User-spec...
Extract repeated logic
microsoft/playwrightWhen you find yourself writing similar code patterns multiple times, extract them into reusable methods, constants, o...
comprehensive test coverage
emcie-co/parlantEnsure tests are comprehensive and explicit to prevent regressions and gaps in coverage. Tests should cover all scena...
Structure tests thoroughly
opentofu/opentofuCreate well-structured tests with thorough coverage of both expected success and error conditions. Name test cases de...
Safe lock patterns
opentofu/opentofuWhen implementing concurrent operations, ensure locks are acquired and released properly in all execution paths. Alwa...
Reduce code nesting
opentofu/opentofuMinimize nesting levels and complexity in your code to improve readability and maintainability. Use early returns ins...
Write purposeful comments
open-telemetry/opentelemetry-pythonComments should explain "why" and "how" rather than restating what is already obvious from the code. Focus on providi...
Sanitize observability data exports
open-telemetry/opentelemetry-pythonWhen exporting observability data (metrics, traces, logs) to external systems, properly sanitize all data fields to e...
Use OpenCV error mechanisms
opencv/opencvAlways use OpenCV's built-in error handling mechanisms instead of C++ exceptions or custom error handling. This ensur...
Prevent null vulnerabilities
opencv/opencvUse container classes and smart pointers instead of manual memory allocation to prevent null pointer dereferences and...
Cross-platform API design rules
opencv/opencvDesign public APIs to work seamlessly across different programming languages and platforms. Follow these key principl...
Clear API contracts
opencv/opencvDesign APIs with clear contracts that behave exactly as their names and signatures suggest. Functions should do preci...
Optimize with standard library
ollama/ollamaWhen implementing algorithms, prefer using Go's standard library over custom implementations or external dependencies...
Use nullable for optionals
octokit/octokit.netWhen a property or parameter represents an optional value that might be absent in requests or responses, use nullable...
validate configuration values
nrwl/nxAlways validate configuration values at runtime and provide clear, actionable error messages when invalid combination...
Use explicit, consistent names
nrwl/nxVariable and parameter names should be explicit about their purpose and consistent with established naming patterns i...
scope CI access tokens
nrwl/nxConfigure CI pipelines to use appropriately scoped access tokens based on branch protection status. Use read-write to...
Document CI configuration clearly
nrwl/nxAlways include file path comments in CI configuration code blocks and use officially recommended setup actions for CI...
Use descriptive names
nuxt/nuxtChoose variable, function, and file names that clearly describe their purpose, behavior, and content. Names should be...
explicit API design
nuxt/nuxtDesign APIs with explicit parameters, consistent return types, and clear interfaces to improve usability and maintain...
Configuration method selection
nuxt/nuxtChoose the appropriate configuration method based on when values are needed and whether they can change at runtime. U...
Use semantic naming patterns
novuhq/novuEstablish consistent naming conventions that preserve semantic meaning and follow established patterns. Use descripti...
Extract reusable components
novuhq/novuEliminate code duplication by extracting common functionality into shared utilities, constants, and base classes. Whe...
Prefer clarity over cleverness
nodejs/nodeWrite code that prioritizes readability and maintainability over cleverness or excessive optimization. Avoid overly c...
Handling Dynamic Content in Next.js Components
vercel/next.jsWhen implementing Next.js components that rely on dynamic content (e.g. random values, current time), it is crucial t...
Provider-specific AI handling
ChatGPTNextWeb/NextChatImplement provider-specific logic when integrating different AI services, as each provider has unique requirements fo...
Use null validation utilities
netty/nettyConsistently use utility methods like `ObjectUtil.checkNotNull()` or `Objects.requireNonNull()` to validate that para...
Memory ordering needs barriers
netty/nettyEnsure proper memory ordering in concurrent code by using appropriate memory barriers and atomic operations based on ...
Structure behavior-driven tests properly
nestjs/nestOrganize tests using behavior-driven development (BDD) patterns to improve clarity and maintainability. Group related...
Follow protocol standards
nestjs/nestWhen implementing networking features, strictly adhere to protocol specifications and standards to ensure proper inte...
prioritize code readability
neovim/neovimWrite code that prioritizes readability and clarity over brevity. Use proper formatting, clear expressions, and consi...
Follow established API patterns
neovim/neovimAPIs should follow documented conventions and established patterns within the codebase to ensure consistency and pred...
Documentation accuracy standards
neovim/neovimEnsure all function documentation accurately reflects the actual code behavior and includes complete, properly format...
Optimize cargo dependencies
neondatabase/neonMaintain clean and efficient dependency configurations in Cargo.toml files by following these practices: 1. **Use wo...
Minimize unnecessary allocations
neondatabase/neonAvoid allocations and cloning when they don't provide sufficient benefit relative to their performance cost. Balance ...
Log level appropriately
neondatabase/neonSelect the appropriate log level based on operational significance and ensure messages are clear, accurate, and forma...
Keep files focused small
neondatabase/neonMaintain code organization by keeping files focused on a single responsibility and splitting large files into smaller...
Standardize LLM interface parameters
n8n-io/n8nMaintain consistent parameter names and interface patterns across LLM implementations to improve maintainability and ...
Sanitize all dynamic content
n8n-io/n8nAlways sanitize dynamic content before rendering to prevent XSS and injection attacks. This includes HTML content, CS...
Never swallow errors silently
n8n-io/n8nAlways handle errors explicitly and preserve their context. Never silently catch and discard errors as this hides bug...
Optimize iteration patterns
apache/mxnetWhen iterating through collections, choose the most efficient iteration pattern based on what information you actuall...
Use descriptive names
rocicorp/monoChoose names that clearly communicate intent and purpose, avoiding vague or misleading terms. Names should be self-do...
explicit null handling
rocicorp/monoUse explicit null and undefined checks with assertions to validate assumptions and maintain type safety. Prefer `!= n...
Environment variable patterns
rocicorp/monoUse consistent patterns for environment variable handling and configuration validation. Access environment variables ...
Use theme utilities consistently
mui/material-uiAlways use theme utilities for consistent styling across the application instead of hard-coded values. Replace direct...
Meaningful and consistent names
mui/material-uiUse descriptive, accurate identifiers that follow established conventions and maintain consistency throughout your co...
Extract complex logic
mastodon/mastodonBreak down complex methods into smaller, well-named private methods to improve readability and maintainability. When ...
Handle errors by severity
maplibre/maplibre-nativeChoose error handling mechanisms based on error severity and recoverability: 1. Use throws for unrecoverable errors ...
Consistent API practices
maplibre/maplibre-nativeMaintain consistency in API design, documentation, and implementation across all supported platforms to improve devel...
Add explanatory documentation
logseq/logseqAdd docstrings to functions and comments to explain complex logic, especially when the purpose or reasoning isn't imm...
consistent naming patterns
lobehub/lobe-chatMaintain consistent naming conventions within related groups of identifiers. When naming related variables, functions...
Provide contextual code documentation
llvm/llvm-projectCode should include documentation that explains the purpose, rationale, and context behind implementation decisions, ...
Follow naming conventions
ggml-org/llama.cppMaintain consistency with established naming patterns and conventions throughout the codebase. This includes matching...
explicit control flow logic
ggml-org/llama.cppUse explicit control flow structures like switch statements instead of complex boolean logic or implicit reasoning wh...
Use proper logging mechanisms
BerriAI/litellmAlways use the logging library instead of print statements and maintain consistent logging patterns throughout the co...
Preserve error handling context
langfuse/langfuseAlways preserve error context by using specific error types, safe error handling patterns, and meaningful error messa...
Maintain naming consistency
langfuse/langfuseUse consistent and descriptive names for variables, components, and functions throughout the codebase. When the same ...
Hook and state correctness
langfuse/langfuseEnsure React hooks and state updates follow best practices to prevent subtle bugs: 1. **Call hooks unconditionally**...
Environment variable documentation
langflow-ai/langflowEnsure comprehensive and accurate documentation of environment variables, including cross-references, auto-detection ...
Prefer nullish coalescing
langchain-ai/langchainjsWhen handling null or undefined values, use modern JavaScript patterns to write more robust and maintainable code: 1...
Prefer descriptive errors
JetBrains/kotlinWhen handling errors in your code, always provide detailed context in error messages to aid debugging. Use Kotlin's s...
Use descriptive names
kilo-org/kilocodeChoose names that clearly communicate purpose, type, and intent rather than generic or ambiguous identifiers. Names s...
extract reusable utilities
kilo-org/kilocodeWhen you notice repeated logic or functions that could be shared across multiple files, extract them into dedicated u...
Synchronization safety patterns
apache/kafkaEnsure proper synchronization mechanisms to prevent deadlocks and race conditions in concurrent code. When designing ...
avoid unnecessary object creation
apache/kafkaMinimize object allocation in performance-critical code paths by reusing existing objects, caching expensive operatio...
Choose efficient data structures
jj-vcs/jjSelect data structures and algorithms based on their performance characteristics and expected usage patterns. Conside...
Return errors explicitly
istio/istioFunctions should return errors explicitly to callers rather than terminating the program, hiding errors in boolean re...
prevent race conditions
istio/istioAlways protect shared state access and ensure proper synchronization in concurrent operations to prevent race conditi...
Feature flag lifecycle management
istio/istioEstablish clear guidelines for feature flag creation, default values, and removal strategy based on risk assessment a...
Avoid expensive operations
istio/istioIdentify and eliminate computationally expensive operations in frequently executed code paths. Common expensive opera...
Wrap errors with context
influxdata/influxdbAlways wrap errors with meaningful context using fmt.Errorf and %w verb. Include relevant identifiers (filenames, IDs...
Follow API conventions
influxdata/influxdbDesign APIs following modern conventions and best practices to improve usability, maintainability, and consistency ac...
Choose optimal data structures
influxdata/influxdbSelect data structures based on specific access patterns and performance requirements. When both fast lookup and pred...
Minimize redundant operations
elie222/inbox-zeroOptimize application performance by preventing unnecessary renders, calculations, and network operations. Implement p...
Handle nulls with types
elie222/inbox-zeroEnforce type safety by properly handling null and undefined values through TypeScript types and explicit checks. Avoi...
Enforce atomic database operations
elie222/inbox-zeroReplace check-then-act patterns with atomic database operations to prevent race conditions in concurrent environments...
Dynamic configuration handling
hyprwm/HyprlandWhen implementing configuration changes that need to be applied at runtime, follow these practices: 1. **Use reload ...
consistent naming conventions
hyprwm/HyprlandFollow the project's established naming conventions consistently across all code. Use camelCase for variables, functi...
Synchronize environment configurations
juspay/hyperswitchWhen making configuration changes, ensure all relevant environment files are updated consistently to prevent environm...
Avoid hardcoded configuration values
juspay/hyperswitchConfiguration values should not be hardcoded in the source code. Instead, they should be externalized to configuratio...
prefer let-else patterns
helix-editor/helixWhen handling Option types that require early returns on None values, prefer the let-else pattern over verbose match ...
Consistent descriptive naming conventions
helix-editor/helixUse consistent and descriptive naming conventions across the codebase: 1. Use kebab-case for configuration options a...
Explicit null validation
grafana/grafanaAlways validate objects for null/nil before accessing their properties, and establish consistent patterns for handlin...
Descriptive semantic names
grafana/grafanaAlways use descriptive variable, parameter, function, and constant names that clearly convey their purpose and behavi...
Use descriptive identifiers
block/gooseReplace generic, ambiguous, or magic identifiers with descriptive, specific names that clearly communicate intent and...
avoid panics and expects
block/gooseReplace panic-inducing operations like `.expect()` and `.unwrap()` with proper error handling that allows graceful re...
avoid environment variable proliferation
block/goosePrefer the consolidated config system over adding new environment variables. Environment variables should only be use...
AI model configuration consistency
block/gooseMaintain consistent AI model metadata and configuration across all providers to prevent breaking changes and ensure r...
Use proper network constants
golang/goWhen writing network-related code, always use named constants from system packages instead of magic numbers, and ensu...
Document code behavior
gin-gonic/ginDocument the "why" and "how" of your code, not just what it does. Add clear comments to explain: 1. Non-obvious beha...
Robust SSH integration
ghostty-org/ghosttyWhen implementing SSH integration in your application, follow these practices to ensure reliability across different ...
Document configs comprehensively
ghostty-org/ghosttyConfiguration options must be documented comprehensively with: 1. Clear, descriptive name using appropriate platform...
Use semantic naming
google-gemini/gemini-cliChoose names that clearly communicate the purpose, behavior, and intent of variables, methods, classes, and interface...
Secure input validation
google-gemini/gemini-cliAlways validate and sanitize user inputs, especially when constructing commands or file paths. Use established securi...
Ensure comprehensive user documentation
google-gemini/gemini-cliAll user-facing features, APIs, and tools must have clear, comprehensive documentation that explains their purpose, l...
Organize code logically
fatedier/frpMaintain a clean and logical code structure by properly organizing code according to its functionality and purpose: ...
Name indicates clear purpose
laravel/frameworkNames should clearly indicate their purpose, type, and behavior. This applies to methods, variables, and parameters. ...
Cache expensive operations
laravel/frameworkIdentify and cache results of expensive operations that may be called repeatedly during a request lifecycle, especial...
Extract methods for clarity
flutter/flutterBreak down large methods and extract repeated code patterns into smaller, focused methods or getters to improve reada...
explicit null validation
flutter/flutterAlways validate null values explicitly rather than using silent fallbacks or implicit handling. When null values are ...
Algorithm precision handling
flutter/flutterChoose algorithms that handle edge cases and mathematical precision correctly to avoid subtle bugs and unexpected beh...
prefer existing APIs
gofiber/fiberWhen adding new functionality, prioritize reusing existing methods and interfaces rather than creating new ones. This...
Extract duplicate logic
gofiber/fiberWhen code blocks become large or contain repetitive patterns, extract them into separate functions to improve readabi...
Consistent test code style
fastify/fastifyMaintain consistent and clear testing patterns by following these guidelines: use strict equality assertions, prefer ...
Concurrent operations completion management
fastify/fastifyWhen running concurrent operations in tests, ensure all operations complete before concluding the test. Race conditio...
Ensure comprehensive test coverage
electron/electronAlways verify that tests cover all relevant scenarios, edge cases, and conditions rather than just the happy path. Wh...
avoid redundant operations
electron/electronIdentify and eliminate unnecessary duplicate operations, redundant function calls, and repeated computations that can...
Use configuration access methods
elastic/elasticsearchWhen accessing configuration settings, always use the appropriate type-safe accessor methods provided by the configur...
Robust test assertions
elastic/elasticsearchUse precise, informative assertions in tests to provide clear feedback when tests fail and verify the correct behavio...
Prefer callbacks over blocking
elastic/elasticsearchAlways structure concurrent code to use asynchronous callbacks instead of blocking operations. Blocking calls like Co...
Measure before optimizing performance
elastic/elasticsearchBefore implementing performance optimizations, measure and validate the impact through benchmarks. This applies espec...
maintain codebase consistency
duckdb/duckdbEnsure new code follows established patterns, conventions, and standards already present in the codebase. This includ...
explicit null state management
duckdb/duckdbMake null state checks explicit and comprehensive rather than using implicit return values or redundant fields. Use d...
Explicit CI configurations
duckdb/duckdbCI/CD workflows should use explicit, named configurations rather than wildcards, globs, or implicit behaviors to impr...
Optional configuration parameters
stanfordnlp/dspyMake configuration parameters optional with sensible defaults instead of requiring mandatory values, and only enable ...
Null safety patterns
stanfordnlp/dspyImplement proper null safety patterns to prevent runtime errors and unexpected behavior. This includes several key pr...
implement algorithms correctly
stanfordnlp/dspyEnsure algorithmic implementations use correct patterns, handle edge cases gracefully, and avoid silent failures. Thi...
API backward compatibility
stanfordnlp/dspyMaintain backward compatibility when evolving API interfaces by preserving existing method signatures and parameter p...
AI configuration documentation
stanfordnlp/dspyEnsure AI model configurations and related documentation use precise terminology and provide clear, complete setup in...
Write focused efficient tests
django/djangoTests should be focused, efficient and meaningful. Follow these guidelines: 1. Avoid testing implementation details ...
Use connection by alias
django/djangoWhen working with database operations in Django projects that might use multiple database backends, always access dat...
Use appropriate log levels
langgenius/difyChoose the correct logging level based on the importance and purpose of the message. Use DEBUG for debugging informat...
Prefer exceptions over silent failures
langgenius/difyRaise exceptions instead of returning None, logging warnings, or silently modifying values when encountering error co...
Concurrent resource management
langgenius/difyWhen implementing concurrent operations, properly manage shared resources to prevent race conditions and ensure syste...
organize code properly
zen-browser/desktopMaintain clean code organization by separating concerns into appropriate classes and files. Extract large functions i...
Validate and document nulls
deeplearning4j/deeplearning4jAlways handle null values explicitly and consistently throughout your codebase to prevent null pointer exceptions. Fo...
Use descriptive names
cypress-io/cypressChoose names that clearly reveal the purpose and behavior of variables, functions, and methods. Names should be self-...
function decomposition clarity
cypress-io/cypressFunctions should be focused, concise, and easy to understand. Break down large functions (>100 lines) into smaller, w...
Consistent formatting preferences
cypress-io/cypressFollow consistent formatting and syntax patterns to improve code readability and maintainability. This includes using...
Structure errors with intent
crewaiinc/crewaiImplement error handling with clear intent and proper propagation. Follow these principles: 1. Use structured try/ca...
Write comprehensive test cases
vuejs/coreTests should thoroughly cover all code paths and edge cases. Each test case should: 1. Test distinct scenarios in sep...
Use appropriate logging levels
home-assistant/coreChoose the correct logging level based on the nature and expected frequency of the event being logged. Follow these g...
Strict props event handling
vuejs/coreEnforce strict typing and consistent handling of component props and events to ensure type safety, runtime validation...
Evolve APIs gracefully
vuejs/coreWhen modifying or extending APIs, prioritize backward compatibility while providing clear migration paths for future ...
ESLint configuration alignment
adonisjs/coreEnsure your ESLint configuration matches the JavaScript language features used in your codebase to prevent false warn...
Choose semantic descriptive names
vuejs/coreNames should be clear, descriptive and follow consistent patterns. Choose names that accurately reflect the purpose a...
Avoid redundant computations
vuejs/coreIdentify and eliminate redundant operations that cause performance bottlenecks by caching expensive function results,...
Semantically consistent naming
continuedev/continueNames should accurately reflect their purpose and be used consistently throughout the codebase. This applies to props...
Handle unsafe operations safely
continuedev/continueAlways wrap potentially unsafe operations (like JSON parsing, Buffer operations, or API calls) in try-catch blocks wi...
Extract into helper functions
continuedev/continueBreak down complex or deeply nested code into smaller, well-named helper functions to improve readability and maintai...
Add logging without duplication
docker/composeWhen adding logging functionality to existing code, encapsulate the logging logic within methods or use parameters to...
Use descriptive names
comfyanonymous/ComfyUIChoose descriptive, self-documenting names for constants, functions, parameters, and types that clearly communicate t...
Hardware compatibility patterns
comfyanonymous/ComfyUIImplement proper hardware compatibility patterns when working with different GPU backends and AI frameworks. Many AI ...
gRPC interface consistency
cline/clineEnsure gRPC/RPC interfaces follow consistent patterns for return types, error handling, and method design. Avoid crea...
Check before property access
cline/clineAlways verify that parent objects and properties exist before accessing nested properties or calling methods on them....
Pin dependency versions
snyk/cliAlways pin dependencies to exact versions in package.json instead of using semantic version ranges (^, ~) to ensure r...
Never commit secrets
chef/chefPrivate cryptographic keys, certificates with private keys, and other secrets must never be committed to source code ...
Memoize expensive operations
chef/chefCache results of expensive operations, especially shell commands and external queries, to avoid redundant executions....
Keep actions versions current
chef/chefAlways use the latest stable versions of GitHub Actions components in CI/CD workflows to avoid deprecated features, s...
Externalize configuration values
chef/chefAvoid hardcoding configuration values directly in scripts, especially for values that might change between environmen...
Choose semantic algorithms
chef/chefSelect algorithms and data operations that match the semantic intent of your code rather than using convenient but po...
Document configuration consistently
bridgecrewio/checkovEnsure all configuration options are clearly documented and follow consistent naming and syntax conventions. This inc...
Select specific database fields
calcom/cal.comAlways explicitly select only the database fields you actually need instead of using broad includes or fetching entir...
Check exceptions consistently
oven-sh/bunAlways check for exceptions immediately after operations that might throw them, especially before using the results i...
Minimize unnecessary operations
Homebrew/brewOptimize performance by eliminating redundant operations and arranging code to avoid unnecessary computations, especi...
Follow established naming patterns
Homebrew/brewNames should be descriptive and consistent with existing patterns in the codebase. This applies to methods, variables...
Clear error recovery paths
Homebrew/brewImplement error handling that provides both clear recovery paths for users and graceful degradation for the system. T...
Clear code examples
Homebrew/brewDocumentation should include clear, actionable code examples that users can reliably follow. Avoid using ambiguous pl...
Comprehensive API documentation
boto/boto3Always provide comprehensive API documentation that includes accurate examples, complete parameter descriptions, and ...
Use consistent error types
better-auth/better-authAlways use the appropriate error classes and throwing mechanisms for consistent error handling across the codebase. P...
Explicit null handling
bazelbuild/bazelAlways make null handling explicit through proper annotations, defensive checks, and clear documentation. Use @Nullab...
Avoid unnecessary computations
bazelbuild/bazelBefore performing expensive operations, check if the work is actually needed or if more efficient alternatives exist....
Use domain-specific type names
Azure/azure-sdk-for-netTypes should be named with clear domain context rather than generic terms. Avoid single-word or overly generic names ...
Minimize memory allocations
Azure/azure-sdk-for-netReduce garbage collection pressure and improve application performance by avoiding unnecessary memory allocations. Th...
Document code reasoning
Azure/azure-sdk-for-netAdd clear, concise comments that explain the "why" behind complex logic, non-obvious decisions, and implicit behavior...
Prefer simpler code constructs
tokio-rs/axumAlways opt for simpler, more idiomatic code constructs over complex or verbose alternatives. This includes using buil...
Semantic naming conventions
aws/aws-sdk-jsUse descriptive, semantic names for all code elements that clearly indicate their purpose and behavior. Follow consis...
Early return after errors
aws/aws-sdk-jsWhen handling errors in asynchronous functions, always return immediately after invoking a callback with an error to ...
Document APIs thoroughly
aws/aws-sdk-jsAll public API elements must be thoroughly documented with JSDoc annotations that clearly explain their purpose, para...
Prefer early returns
argoproj/argo-cdUse early returns and guard clauses to reduce nesting levels and improve code readability. Instead of deeply nested i...
Complete configuration examples
argoproj/argo-cdConfiguration examples in documentation must be complete and reference authoritative sources to prevent deployment is...
Use language-specific syntax
appwrite/appwriteCode snippets must use the correct language-specific syntax and include all necessary imports to compile properly. Wh...
Synchronize configuration values
appwrite/appwriteEnsure all configuration values, particularly version numbers and environment variables, are consistent across relate...
Secure authorization skip handling
appwrite/appwriteWhen using authorization bypass mechanisms like `Authorization::skip()`, ensure proper security validation is maintai...
Markdown formatting consistency
ant-design/ant-designEnsure consistent markdown formatting in documentation by wrapping all technical terms, API names, property names, an...
JSDoc deprecation formatting
ant-design/ant-designEnsure consistent formatting in JSDoc deprecation comments to improve API documentation clarity and developer experie...
Dependency versioning consistency
ant-design/ant-designEstablish and maintain consistent dependency versioning strategies in package.json configuration. Choose between care...
Use reactive signal patterns
angular/angularPrefer Angular's reactive signal patterns over manual subscription management and imperative approaches. Use signals ...
leverage existing Angular patterns
angular/angularBefore implementing new functionality, check if Angular already provides a suitable utility, service, or pattern that...
Validate user-controlled paths
apache/airflowAlways validate and sanitize user-provided inputs used in file path operations to prevent path traversal attacks. Pat...
Standardize API parameter handling
apache/airflowUse consistent parameter handling patterns across API endpoints to ensure maintainability and predictable behavior. F...
Avoid code duplication
apache/airflowExtract repeated code patterns into reusable functions, variables, or constants to improve maintainability and reduce...
Verify AI model capabilities
vercel/aiAlways verify and accurately document AI model capabilities, supported formats, and limitations before implementation...
Type-safe null handling
vercel/aiUse TypeScript's type system and modern JavaScript features to prevent null reference errors. **TypeScript type saf...
Keep tests simple
vercel/aiTests should be straightforward, explicit, and free from complex logic or indirection. Avoid "magic" in tests that ma...
Test actual functionality
cloudflare/agentsEnsure tests verify real operations and integration scenarios rather than just basic concepts or type definitions. Ma...
Use structured model metadata
zed-industries/zedRepresent AI model information using structured data rather than hardcoded enumerations or conditionals. Store capabi...
Scope dependencies appropriately
zed-industries/zedConfigure dependencies with their minimum necessary scope to maintain clean architecture and improve build times. Key...
Document configuration constraints clearly
zed-industries/zedWhen defining configuration options, always clearly document parameter constraints, valid ranges, and behaviors. For ...
Choose domain-specific semantic names
zed-industries/zedNames should clearly reflect their domain-specific meaning and purpose, avoiding generic or ambiguous terms. This app...
Strict null checks
facebook/yogaUse explicit strict equality checks when testing for null or undefined values. Prefer `x === undefined` over `typeof ...
Explicit undefined state handling
facebook/yogaAlways use explicit, well-defined representations for undefined, uninitialized, or invalid states instead of magic va...
JSDoc documentation standards
cloudflare/workers-sdkAll public functions and complex code should have proper JSDoc documentation. Functions must include clear descriptio...
Configuration file consistency
cloudflare/workers-sdkEnsure consistent patterns for configuration files, proper exclusion of development artifacts, and clear environment-...
proper span lifecycle management
cloudflare/workerdEnsure spans are properly created, attached to async operations, and reported at appropriate times to maintain accura...
Network resource state validation
cloudflare/workerdAlways validate the state of network resources (sockets, streams, connections) before performing operations to preven...
compatibility flag consistency
cloudflare/workerdEnsure compatibility flags follow consistent naming conventions, use explicit typing, and maintain proper usage patte...
avoid unnecessary allocations
cloudflare/workerdMinimize object creation and memory copying operations to improve performance. Cache and reuse objects when possible,...
Use structured logging
volcano-sh/volcanoAlways use structured logging methods like klog.InfoS and klog.ErrorS instead of unstructured methods like klog.Infol...
Use descriptive consistent naming
volcano-sh/volcanoChoose names that are self-explanatory, descriptive, and consistent across the codebase. Avoid abbreviated or informa...
Validate algorithmic operations carefully
vllm-project/vllmMathematical and logical operations require careful validation to ensure correctness. Common issues include: 1. Oper...
Remove unnecessary code elements
vllm-project/vllmKeep code clean and maintainable by removing unnecessary elements that add complexity without value: 1. Remove unuse...
Preserve API compatibility
vllm-project/vllmWhen modifying API interfaces, parameters, or argument behavior, ensure backward compatibility is maintained to preve...
Optimize memory allocation
vitessio/vitessAlways allocate data structures with appropriate initial capacity and use memory-efficient data types to reduce memor...
Runtime-agnostic API design
vitejs/viteWhen designing APIs for systems that support multiple JavaScript runtimes, prioritize decoupling server state from us...
Propagate errors with context
vitejs/viteAlways propagate errors with proper context and recovery strategy. Use try-catch blocks for both synchronous and asyn...
Environment variable management
vitejs/viteWhen working with environment variables in Vite applications, be explicit about variable loading behavior and precede...
Runtime configurable defaults
vlang/vPrefer runtime-configurable values over hardcoded constants to allow users to customize behavior without recompilatio...
Secure configuration defaults
astral-sh/uvEstablish secure default configurations in project metadata files to prevent accidental publishing and ensure proper ...
Optimize CI/CD commands
astral-sh/uvDesign CI/CD workflows to be efficient, consistent, and purposeful across all environments. When writing or modifying...
Environment variable best practices
astral-sh/uvWhen implementing environment variable configuration: 1. Follow standard environment variable conventions: - Use upp...
Raise exceptions properly
Unstructured-IO/unstructuredAlways ensure exceptions are properly raised and propagated rather than being logged and swallowed. Avoid patterns wh...
extensible parameter design
Unstructured-IO/unstructuredDesign API parameters to support future extension without breaking changes. Use string enums instead of boolean flags...
Environment variable patterns
Unstructured-IO/unstructuredUse consistent patterns for environment variable handling in shell scripts. Always provide sensible defaults using th...
Meaningful consistent identifiers
shadcn-ui/uiChoose descriptive, semantically accurate names for variables, types, and components that clearly communicate their p...
Guard against undefined
microsoft/typescriptAlways protect against potential null or undefined values before attempting property access or method calls to preven...
Extract complex logical expressions
microsoft/typescriptComplex logical expressions should be extracted into well-named variables or functions to improve code readability an...
prefer type guards
twentyhq/twentyUse semantic type guards like `isDefined()` instead of basic type checks (`typeof`, simple null checks) or unsafe typ...
Minimize hook re-renders
twentyhq/twentyDesign React hooks to minimize unnecessary re-renders by avoiding common anti-patterns that cause performance issues....
Add tests for functionality
twentyhq/twentyNew functionality should include corresponding tests to ensure code quality and maintainability. When introducing new...
Validate performance impact first
vercel/turborepoAlways validate performance changes through profiling or benchmarking before implementation, and favor memory-efficie...
Design ergonomic APIs
vercel/turborepoCreate APIs that are both easy to use correctly and hard to use incorrectly. Focus on: 1. **Use pattern matching for...
Use meaningful identifiers
tree-sitter/tree-sitterChoose identifiers that accurately represent their purpose, semantics, and relationship to the codebase. Names should...
Use descriptive identifiers
tree-sitter/tree-sitterChoose identifiers that clearly communicate their purpose, content, or role rather than using generic or abbreviated ...
Ensure documentation clarity
tree-sitter/tree-sitterDocumentation should be clear, accurate, and provide meaningful information to users. Avoid misleading descriptions, ...
consistent formatting preferences
tree-sitter/tree-sitterMaintain consistent formatting and use concise, standard syntax throughout the codebase. This includes several specif...
complete API documentation
traefik/traefikEnsure all API configuration options are fully documented with accurate default values, required field indicators, an...
Structure feature flags strategically
tokio-rs/tokioDesign feature flags to minimize dependency bloat while maximizing flexibility for users. Each optional dependency sh...
Structure API doc blocks
tokio-rs/tokioEach public API documentation block should follow a consistent structure: 1. Start with a single-line summary that c...
Socket configuration guidance
tokio-rs/tokioWhen implementing networking APIs, always clearly document socket modes, configuration options, and platform-specific...
Optimize hot paths
tokio-rs/tokioIdentify and optimize frequently executed code paths to improve performance. Hot paths have a significant impact on o...
Graceful error handling
tokio-rs/tokioPrioritize graceful error handling over panicking by providing fallbacks and propagating rich context. When operation...
Fast deterministic tests
tokio-rs/tokioAvoid using real sleeps or delays in tests as they significantly slow down the test suite and can introduce flakiness...
Design flexible APIs
tokio-rs/tokioWhen designing APIs, prioritize flexibility, ergonomics, and intuitiveness to create better user experiences. APIs sh...
Minimize memory allocations
huggingface/tokenizersAvoid unnecessary memory allocations to improve performance. Each allocation has both CPU and memory overhead that ca...
Handle nullable types idiomatically
huggingface/tokenizersUse Rust's idiomatic patterns when working with Option and Result types to prevent panics and improve code clarity. ...
Use precise semantic names
hashicorp/terraformChoose names that accurately reflect the purpose and semantics of the entity being named. Avoid overloaded or ambiguo...
Prefer modern authentication
hashicorp/terraformAlways use modern identity-based authentication methods instead of static credentials when accessing external systems...
Include descriptive documentation
hashicorp/terraformProvide complete, clear descriptions for all configuration elements in documentation. Every output, variable, argumen...
Document function behavior completely
hashicorp/terraformFunction and method documentation should accurately describe behavior, parameters, and any non-obvious aspects of the...
prefer const declarations
microsoft/terminalUse `const` for variables that are not modified after initialization, and avoid creating unnecessary temporary variab...
Validate quantization parameters carefully
tensorflow/tensorflowWhen implementing quantized operations in ML models, thoroughly validate quantization parameters to ensure correctnes...
Validate before dereference
tensorflow/tensorflowAlways check that pointers, optional values, and results of type casts are valid before dereferencing or using them. ...
Optimize loop operations
tensorflow/tensorflowMinimize expensive operations within inner loops to improve performance. Key practices include: 1. Extract loop-inva...
Informative error messages
tensorflow/tensorflowError messages should be informative, actionable, and concise to help users quickly understand and fix issues. Follow...
Handle dynamic shapes
tensorflow/tensorflowWhen implementing tensor-based algorithms, avoid assumptions about fixed tensor shapes by not relying on direct shape...
Optimize metrics label cardinality
temporalio/temporalCarefully manage metric label cardinality to prevent excessive memory usage and maintain system performance. Follow t...
Domain-specific error boundaries
temporalio/temporalDefine and use domain-specific error types within bounded contexts rather than relying on generic service errors. Eac...
Design stable APIs
temporalio/temporalWhen designing APIs, prioritize long-term stability and compatibility to avoid breaking changes. Use request/response...
Use appropriate testify assertions
gravitational/teleportChoose the most specific and appropriate testify assertion methods for your test scenarios to improve test clarity, e...
minimize unnecessary allocations
gravitational/teleportAvoid unnecessary memory allocations in performance-critical code paths, especially in frequently executed functions ...
Configuration requirements clarity
gravitational/teleportConfiguration requirements and dependencies should be made explicit and prominent in documentation, not buried in not...
API consistency patterns
gravitational/teleportMaintain consistent API patterns and structures across different resource types and access methods within the same sy...
Teach by example
tensorflow/swiftPresent concepts through clear, focused examples that demonstrate features positively rather than through comparisons...
Explicit configuration validation
SWE-agent/SWE-agentAvoid using configuration values as implicit feature flags or logic triggers. Instead, validate configuration explici...
prefer testing libraries
sveltejs/svelteWhen testing components, use established testing libraries like @testing-library/svelte instead of low-level DOM mani...
defensive error handling
sveltejs/svelteAdd defensive checks and proper error handling to prevent crashes and handle edge cases gracefully. This includes usi...
avoid expensive operations
sveltejs/svelteIdentify and eliminate computationally expensive operations through early termination, better data structures, and al...
Structure components with clarity
supabase/supabaseMaintain clean and logical component organization by following these guidelines: 1. Keep related files together - pl...
Clear, descriptive identifiers
supabase/supabaseChoose variable, component, and parameter names that clearly describe their purpose and avoid ambiguity. Names should...
Use structured logging consistently
browserbase/stagehandAlways use the established logging framework instead of console.log or ad-hoc logging approaches. This ensures consis...
Use descriptive names
browserbase/stagehandChoose descriptive, domain-specific names that clearly communicate intent and prevent confusion. Avoid generic names ...
Provide contextual error messages
browserbase/stagehandError messages should include specific context about what went wrong and provide actionable guidance for resolution. ...
Leverage TypeScript null safety
browserbase/stagehandUse TypeScript's type system proactively to prevent null and undefined issues at compile time rather than handling th...
Respect annotation processing order
spring-projects/spring-frameworkWhen designing Spring components, pay careful attention to the order in which annotations are processed, especially f...
Design for API extension
spring-projects/spring-frameworkWhen designing APIs, prioritize extensibility by providing clear extension points and avoiding direct exposure of imp...
Cleanup error handling
spring-projects/spring-frameworkWhen handling resources that require cleanup (like streams, connections, or transactions), ensure that errors during ...
API boundary null handling
spring-projects/spring-frameworkEstablish consistent null handling patterns at API boundaries to prevent null pointer exceptions and improve code cla...
Property description conventions
spring-projects/spring-bootWhen documenting configuration properties in Spring Boot applications, follow these conventions for clarity and consi...
prefer simple APIs
apache/sparkDesign APIs with simplicity in mind by avoiding unnecessary method overloads, reducing configuration options, and pre...
Include contextual information
apache/sparkLog messages should include comprehensive contextual information to support debugging and system monitoring. This inc...
avoid unnecessary computations
apache/sparkPrevent performance degradation by avoiding unnecessary expensive operations such as premature execution, redundant i...
Use appropriate error types
SigNoz/signozAlways use semantically correct error types and codes that match the actual failure scenario. This ensures proper err...
Centralize configuration management
SigNoz/signozConsolidate configuration parameters into centralized config structures instead of using scattered options structs or...
Use descriptive names
sgl-project/sglangChoose variable, function, and parameter names that accurately reflect their content, type, and purpose. Avoid mislea...
conditional CI execution
servo/servoUse appropriate conditional statements in CI workflows to ensure steps execute under the right circumstances and hand...
Structure configs for clarity
serverless/serverlessOrganize configuration objects to maximize clarity and maintainability while ensuring robust validation. Follow these...
API clarity and consistency
serverless/serverlessEnsure API configurations, documentation, and terminology are clear, consistent, and properly organized. Group relate...
exact assertion testing
oraios/serenaTests should verify exact expected results rather than generic existence checks. Avoid assertions like `isinstance()`...
Secure sensitive data
getsentry/sentryAlways protect sensitive data through proper encryption, secure cookies, and careful exception handling to prevent in...
Remove unnecessary code elements
getsentry/sentryKeep code clean and maintainable by removing unnecessary elements. This includes: 1. Omit type annotations when Type...
Prevent N+1 database queries
getsentry/sentryAvoid N+1 database queries by using appropriate Django ORM features like select_related(), prefetch_related(), and bu...
Propagate errors with context
getsentry/sentry-phpAlways propagate errors appropriately by rethrowing caught exceptions and maintaining error context. Catch exceptions...
Document API changes
getsentry/sentry-phpWhen documenting API changes, particularly breaking changes, follow these practices to ensure clarity and ease of mig...
Defensive null checking
getsentry/sentryImplement defensive null checking to prevent NoneType errors, KeyError, and IndexError exceptions. When accessing dic...
Choose efficient algorithms
semgrep/semgrepWhen implementing algorithms, prioritize computational efficiency by selecting appropriate data structures and avoidi...
Fail fast explicitly
strands-agents/sdk-pythonAlways throw exceptions for error conditions rather than silently failing, logging warnings, or attempting fallback b...
explicit null checks
strands-agents/sdk-pythonUse explicit existence checks rather than value-based null checks, and be intentional about failing fast versus provi...
comprehensive test assertions
strands-agents/sdk-pythonWrite robust test assertions that verify complete objects and behaviors rather than individual properties. Use pytest...
Complete docstring documentation
strands-agents/sdk-pythonEnsure all classes, methods, and properties have comprehensive docstrings that clearly explain their purpose, behavio...
AI provider normalization
strands-agents/sdk-pythonWhen integrating multiple AI model providers, implement proper abstraction layers to normalize differences in APIs, d...
Name for semantic meaning
rust-lang/rustChoose names that clearly convey the semantic meaning and purpose of the identifier, rather than using clever or ambi...
Document lock behavior
rust-lang/rustWhen implementing or documenting synchronization primitives, always clearly specify how locks behave under exceptiona...
Benchmark before optimizing code
rust-lang/rustAlways validate performance optimizations with benchmarks before implementation. Ensure measurements account for: 1. ...
Prevent null references
dotnet/runtimeUse defensive coding practices to prevent null reference exceptions by properly handling potentially null values thro...
Maintainable test structure
dotnet/runtimeWrite tests that are maintainable, self-documenting, and that promote good testing practices: 1. **Use proper assert...
Document code meaningfully
dotnet/runtimeProvide meaningful documentation that enhances code maintainability and understanding. Follow these practices: 1. **...
Cache expensive computations
dotnet/runtimeAvoid recomputing expensive operations by caching results when they will be used multiple times. This applies to meth...
Avoid busy waiting
dotnet/runtimeWhen implementing concurrent code that waits for conditions to be met, avoid busy-wait loops that continuously consum...
Abstract traversal patterns
dotnet/runtimeWhen implementing algorithms that operate on complex data structures (trees, graphs, dominator structures), abstract ...
Use descriptive identifiers
astral-sh/ruffAvoid abbreviations in variable, parameter, and method names to improve code readability and maintainability. Use des...
Profile allocations before optimization
astral-sh/ruffBefore implementing data structures or algorithms, analyze allocation patterns and optimize for common cases. Key str...
Document component behavior comprehensively
astral-sh/ruffDocumentation should clearly explain the purpose, behavior, and relationships between code components using accessibl...
Consider algorithmic complexity tradeoffs
astral-sh/ruffWhen implementing algorithms or data structures, carefully evaluate the tradeoffs between computational complexity, m...
validate configuration schemas
TanStack/routerAlways validate configuration objects using proper schema validation (like Zod) before type casting or using the conf...
validate before accessing
TanStack/routerAlways validate that values exist and have expected properties before accessing them, especially when removing non-nu...
Use parameterized testing
TanStack/routerWhen testing multiple scenarios with similar logic, use your testing framework's built-in parameterized testing featu...
Maintain comprehensive documentation
TanStack/routerWhen making code changes, ensure all relevant documentation is updated comprehensively across different formats and l...
explicit error type handling
TanStack/routerHandle errors with explicit type checking and intentional decisions rather than generic catch-all approaches. This im...
Configuration option consistency
TanStack/routerEnsure configuration options follow consistent naming conventions and are documented accurately. Use "default" prefix...
Write resilient test assertions
RooCodeInc/Roo-CodeWrite test assertions that are resilient to implementation changes by focusing on behavior rather than implementation...
Use structured logging
RooCodeInc/Roo-CodeReplace direct `console.log`, `console.warn`, and `console.error` calls with a centralized logging abstraction. This ...
Prevent duplicate keys
RooCodeInc/Roo-CodeAlways ensure configuration files, especially JSON files, have unique keys. Duplicate keys can cause unpredictable be...
maintain naming consistency
remix-run/react-routerEnsure consistent naming conventions across the entire codebase, including terminology, file names, directory structu...
dependency version ranges
remix-run/react-routerWhen configuring dependencies in package.json, use version ranges that maintain backwards compatibility and follow se...
Configure rendering modes clearly
remix-run/react-routerEnsure clear distinction and proper handling between different rendering modes (SSR, SSG, SPA) with appropriate condi...
API naming consistency
remix-run/react-routerEnsure related APIs use consistent naming patterns, parameter structures, and calling conventions across the codebase...
validate before accessing
facebook/react-nativeAlways validate parameters for both null values and correct types before accessing their properties or methods. Provi...
Prefer micro-optimizations
facebook/react-nativeApply small performance improvements that accumulate to significant gains. Focus on efficient memory usage, API choic...
Early returns prevent waste
facebook/react-nativeAdd early return statements and duplicate checks to avoid unnecessary computations, memory allocations, and API calls...
Document configuration logic
facebook/react-nativeAlways add clear, explanatory comments for conditional configuration logic, architectural decisions, and platform-spe...
avoid Hungarian notation
facebook/react-nativeDo not use Hungarian notation prefixes (like `m`, `s`) in variable and field names. Use descriptive, semantic names t...
Write complete API examples
rails/railsAlways provide complete, context-rich code examples in API documentation. Examples should show the full usage context...
Place configurations appropriately
rails/railsChoose the right location and scope for your Rails configuration options to improve maintainability and clarity: 1. ...
Initialize nil-prone variables
rails/railsAlways initialize variables that might be nil to appropriate default values to prevent unexpected behavior. For boole...
Prefer Optional over nulls
quarkusio/quarkusUse Java's Optional API instead of null checks to improve code readability, safety, and maintainability. When dealing...
Optimize algorithmic operations
quarkusio/quarkusBefore implementing or modifying algorithms, carefully evaluate data structure properties and operation costs. Always...
Name for meaning first
quarkusio/quarkusChoose names that prioritize domain meaning and clarity over implementation details. This applies to methods, variabl...
Document public APIs
quarkusio/quarkusAll public APIs, interfaces, and methods should include comprehensive JavaDoc that clearly explains their purpose, pa...
Clear database configuration examples
quarkusio/quarkusDatabase configuration examples in documentation should be correct, minimal, and include proper context. Provide only...
Use higher-level iterations
pytorch/pytorchWhen working with multiple sequences that need to be combined, prefer higher-level iteration abstractions over nested...
Prevent null pollution
pytorch/pytorchDesign your code to minimize the unexpected introduction of None values into data structures and APIs. Use immutable ...
Handle errors specifically
pytorch/pytorchAlways be explicit and specific when handling errors rather than using catch-all approaches or implicit conventions. ...
Robust error messaging
pydantic/pydanticCreate clear, specific, and actionable error messages that help users understand and resolve issues, while implementi...
Eliminate redundant computation
pydantic/pydanticIdentify and eliminate redundant or duplicate computation paths in your code, especially for expensive operations lik...
Cache expensive computations
pydantic/pydanticImplement strategic caching and memoization for expensive or frequently repeated computations to avoid redundant work...
Secure authentication flows
prowler-cloud/prowlerImplement authentication flows that protect sensitive information and follow secure credential management practices: ...
Safe attribute access patterns
prowler-cloud/prowlerImplement consistent patterns for safely accessing potentially null or undefined attributes and dictionary values. Th...
Prioritize code readability
prowler-cloud/prowlerWrite code that optimizes for human readability and understanding. Complex expressions, while technically correct, ca...
Consistent naming patterns
prowler-cloud/prowlerFollow systematic naming conventions for types, interfaces, and functions to enhance code readability and navigabilit...
simplify test structure
prometheus/prometheusWrite tests that are direct, focused, and free of unnecessary complexity. Remove redundant test fields, use direct as...
explicit test assertions
prometheus/prometheusTests should explicitly assert both positive and negative expectations to make test intentions clear and prevent regr...
avoid panics gracefully
prometheus/prometheusNever use panic() for error handling in production code paths, especially in core engine components. Instead, handle ...
Avoid unnecessary allocations
prisma/prismaMinimize memory allocations by avoiding intermediate objects, sharing underlying buffers, and eliminating unnecessary...
validate configuration values
prettier/prettierAlways validate configuration values and provide clear, actionable error messages when validation fails. Handle inval...
Modern configuration formats
prettier/prettierPrefer ES module configuration files with TypeScript annotations over JSON formats for better developer experience an...
Add explanatory comments
prettier/prettierAdd explanatory comments for complex logic, special cases, or non-obvious code behavior. Comments should explain the ...
Maintain naming consistency
PostHog/posthogEnsure consistent naming conventions, terminology, and identifiers across the entire codebase. Names should be unifor...
eliminate code duplication
PostHog/posthogActively identify and eliminate code duplication in all its forms to improve maintainability and reduce bugs. This in...
Cache expensive operations
PostHog/posthogIdentify and eliminate redundant expensive operations by implementing caching, memoization, or conditional execution....
break down large functions
PostHog/posthogLarge functions that handle multiple responsibilities should be decomposed into smaller, focused functions to improve...
Hide implementation details
pola-rs/polarsDesign public APIs to hide implementation details and focus on the user's mental model of the system. Avoid exposing ...
Explicit configuration precedence
pola-rs/polarsImplement a clear configuration resolution chain that follows a consistent precedence pattern: explicit parameters fi...
Evaluate algorithmic complexity tradeoffs
pola-rs/polarsWhen implementing algorithms, carefully evaluate tradeoffs between performance optimizations and code maintainability...
Documentation clarity standards
python-poetry/poetryEnsure documentation is grammatically correct, clearly structured, and uses precise terminology. Avoid verbose or rep...
Configure HTTP requests properly
python-poetry/poetryWhen making HTTP requests, use standard library enums for status codes, set appropriate timeouts, and handle redirect...
Synchronous event handlers
microsoft/playwrightKeep event handlers synchronous to prevent race conditions and timing issues. Async operations within event handlers ...
comprehensive test coverage
microsoft/playwrightTests should be comprehensive and cover edge cases, complete scenarios, and use specific assertions rather than gener...
API parameter clarity
microsoft/playwrightDesign API parameters to be self-documenting and minimize cognitive overhead. Avoid boolean parameters in favor of de...
preserve exception context
emcie-co/parlantWhen handling exceptions, preserve the original exception context and provide clear, actionable error information. Av...
Names reflect exact purpose
emcie-co/parlantChoose names that precisely reflect the component's purpose and behavior, avoiding ambiguous terms or shortcuts. Name...
LLM provider abstraction
emcie-co/parlantWhen integrating with different LLM providers, create proper base class abstractions that filter and validate paramet...
Document with examples
opentofu/opentofuAlways include clear, contextual examples when documenting APIs, interfaces, or command-line functionality. Examples ...
Defensive null handling
opentofu/opentofuAlways initialize data structures before use, particularly before accessing them in loops or conditional blocks. Chec...
Clear concise documentation
opentofu/opentofuWrite documentation that is direct, consistent, and appropriately detailed. Follow these principles: 1. **Use direct...
Optimize configuration structure
open-telemetry/opentelemetry-pythonStructure configuration files like tox.ini to maximize maintainability and efficiency. Use factor prefixes (e.g., "te...
Handle exceptions appropriately
open-telemetry/opentelemetry-pythonWhen implementing error handling logic, be deliberate about which exception types you catch and where you handle them...
Follow Python naming conventions
open-telemetry/opentelemetry-pythonUse consistent Python naming conventions to improve code readability and maintainability: 1. Use snake_case for func...
Configuration source precedence
open-telemetry/opentelemetry-pythonDefine and document a clear precedence order when configurations come from multiple sources (code parameters, environ...
Use environment variables
commaai/openpilotMake configuration values configurable through environment variables with sensible defaults instead of hard-coding th...
use context managers concurrency
commaai/openpilotWhen working with concurrent operations involving shared resources or processes, use context managers and explicit sy...
eliminate unnecessary code
commaai/openpilotRemove redundant code constructs and prefer concise, direct patterns that improve readability and maintainability. Th...
Context-aware algorithm selection
opengrep/opengrepChoose algorithms and data structures based on operational requirements and usage context rather than defaulting to f...
Optimize memory allocation patterns
opencv/opencvPrefer efficient memory allocation patterns to improve performance. Key practices: 1. Use RAII containers (like Mat)...
Optimize container access
opencv/opencvChoose efficient container types and optimize access patterns in performance-critical code. Avoid operations that cau...
Maintain code consistency
opencv/opencvKeep code clean and consistent with established project conventions. This includes: 1. Follow existing formatting st...
Guard optional dependencies
opencv/opencvConfiguration management requires careful handling of optional dependencies in both build scripts and source code. Al...
Use idiomatic Go flow
ollama/ollamaFollow Go's idiomatic control flow patterns to improve code readability and maintainability. Key practices include: ...
Use environment variables
ollama/ollamaUse environment variables instead of hardcoding configuration values such as file paths, port numbers, or system-spec...
Guard against nil
ollama/ollamaAlways check for nil values and successful type assertions before accessing or dereferencing objects, especially when...
Document synchronization intent
ollama/ollamaAlways clearly document the purpose and scope of synchronization primitives (mutexes, read-write locks) by: 1. Placi...
Comprehensive test coverage
ollama/ollamaTest functions should provide comprehensive coverage of both expected and edge cases. Include tests for: 1. **Bounda...
Clear recoverable error messages
ollama/ollamaError messages should be clear, actionable, and indicate whether recovery is possible. When designing error handling:...
Abstract model operations cleanly
ollama/ollamaWhen implementing AI model operations, create clean abstractions through interfaces that separate core mathematical o...
Design intuitive API methods
octokit/octokit.netWhen designing API methods, prioritize intuitive usage patterns and backwards compatibility. Follow these guidelines:...
Verify configuration paths
nrwl/nxEnsure configuration property paths are accurate and complete, especially for nested configurations and context-speci...
Use nullish coalescing operators
nrwl/nxPrefer modern JavaScript nullish coalescing (`??`) and optional chaining (`?.`) operators over verbose conditional lo...
minimize resource usage
nrwl/nxOptimize performance by being selective about resource consumption - process only necessary data, avoid redundant ope...
Follow Vue API patterns
nuxt/nuxtAlways prefer Vue's native APIs and follow official Vue patterns instead of creating custom implementations. This ens...
explicit response types
nuxt/nuxtAlways specify explicit response types when making API calls, especially for prerendered routes or external APIs. In ...
Extract repeated patterns
novuhq/novuExtract repeated code patterns, CSS classes, and constants to improve maintainability and reduce duplication. When th...
Environment variable fallbacks
novuhq/novuAlways implement proper fallback chains for environment variables and handle missing configuration gracefully. When i...
contextual API parameters
novuhq/novuDesign APIs to provide contextual information and adapt behavior based on current usage context. Pass context objects...
Use modern C++ features
nodejs/nodeEmbrace modern C++20 features throughout the codebase to improve code readability, maintainability, and performance. ...
Thread-safe resource management patterns
nodejs/nodeEnsure thread-safe access to shared resources while following proper resource management patterns. When implementing ...
Standardize null pointer checks
nodejs/nodeAlways use standard null-checking patterns like CHECK_NOT_NULL for pointer validation instead of manual null checks. ...
Propagate errors with context
nodejs/nodeAlways propagate errors with their original context instead of swallowing them or throwing new errors that hide the o...
Minimize configuration dependencies
nodejs/nodeKeep configuration dependencies minimal and platform-aware. Avoid including unnecessary configuration files or extern...
Follow consistent naming patterns
nodejs/nodeMaintain consistent naming conventions throughout the codebase to improve readability and reduce confusion. Adhere to...
Document with precise accuracy
nodejs/nodeMaintain precise and accurate documentation through both JSDoc annotations and explanatory comments. Ensure all techn...
Behavior-focused test design
nodejs/nodeTests should focus on verifying behavior rather than implementation details to ensure they remain robust during refac...
Write robust assertions
vercel/next.jsWhen writing tests, ensure assertions can handle non-deterministic content while providing clear failure context: use...
Optimize Next.js Resource Utilization
vercel/next.jsAs a code reviewer, I recommend the following practices to optimize resource utilization when implementing Next.js ap...
Release resources consistently
netty/nettyAlways ensure resources are properly released, especially in exception paths. Use try-finally blocks to guarantee cle...
Use consistent curly braces
nestjs/nestAlways use curly braces for conditional statements and loops, even for single-line bodies. This maintains consistency...
Strategic dependency configuration
nestjs/nestConfigure dependencies in package.json strategically based on how they're used in your project: 1. **Direct dependen...
Standardize null safety patterns
nestjs/nestUse modern JavaScript features and utility functions consistently for null/undefined checks. Prefer optional chaining...
Preserve public API stability
nestjs/nestWhen modifying or extending public interfaces, ensure changes maintain backward compatibility and follow proper versi...
Preserve API interface stability
nestjs/nestWhen modifying or extending public API interfaces, ensure backward compatibility and proper versioning. Follow these ...
Modern null safety patterns
nestjs/nestLeverage modern JavaScript features and utility functions for safer null/undefined handling. This reduces code verbos...
Avoid testing anti-patterns
nestjs/nestEnsure your tests actually validate functionality by avoiding common testing anti-patterns: 1. **Don't mock what you...
validate early, fail fast
neovim/neovimPerform comprehensive input validation and precondition checks at the beginning of functions, before executing any op...
Provide helpful documentation context
neovim/neovimDocumentation should include sufficient context, practical examples, and helpful hints to make it truly useful for de...
prefer concise expressions
neovim/neovimWrite concise, readable code by choosing the most direct expression for simple operations. Use ternary operators for ...
Use descriptive identifiers
neondatabase/neonChoose clear, meaningful names for variables, parameters, and constants that convey their purpose without requiring a...
Stage configuration changes gradually
neondatabase/neonWhen introducing configuration changes that affect multiple system components, implement them in stages to ensure smo...
Hierarchical semantic naming
neondatabase/neonUse hierarchical prefixes and clear descriptive names to indicate the domain, source, and purpose of code elements. T...
Flexible documented configurations
neondatabase/neonCreate configuration interfaces that are flexible, well-documented, and future-proof. When designing configuration pa...
Document concurrency design decisions
neondatabase/neonAlways document key concurrency design decisions in code, including: 1. Locking protocols and ordering between multip...
Design metrics for insights
neondatabase/neonDesign metrics that provide actionable insights while maintaining system efficiency. Follow these key principles: 1....
Comprehensive code documentation
neondatabase/neonProperly document code with clear, accurate, and useful comments using the correct syntax based on context: 1. Use `...
Validate API data contracts
n8n-io/n8nAlways validate API request and response data using schema validation to ensure type safety and prevent runtime error...
Optimize loop operations
n8n-io/n8nAvoid repeated computations and object creation in loops or high-frequency operations. Move invariant calculations ou...
Manage database connections
n8n-io/n8nAlways properly manage database connections to prevent resource leaks and improve application stability. Implement th...
Use intent-revealing names
apache/mxnetChoose names that clearly reveal the purpose, behavior, or type of the code elements they represent. A good name shou...
Hybridization compatible operations
apache/mxnetWhen implementing neural network models that will be hybridized for performance optimization, use operations that are...
Explain optimization mechanisms
apache/mxnetWhen implementing or documenting performance optimizations, clearly explain the mechanism and expected performance be...
Document all parameters
apache/mxnetAlways provide complete and accurate documentation for all function parameters, especially when adding new ones. Each...
preserve error context
rocicorp/monoWhen propagating errors through promise rejections, catch blocks, or error transformations, always preserve the origi...
minimize hot path allocations
rocicorp/monoReduce memory allocations and garbage collection pressure in frequently executed code paths. Object creation through ...
avoid unnecessary computations
rocicorp/monoOptimize algorithms by eliminating redundant work and intermediate data structures. Look for opportunities to use laz...
API consistency patterns
rocicorp/monoMaintain consistent patterns across similar APIs to improve developer experience and reduce cognitive overhead. When ...
Add missing test coverage
rocicorp/monoIdentify and address gaps in test coverage by requesting specific tests for untested functionality. When reviewing co...
Configure CSS layers
mui/material-uiWhen integrating Material UI with other styling solutions like Tailwind CSS v4, proper configuration of CSS layers is...
Use semantic naming
mastodon/mastodonChoose names that clearly communicate purpose and align with established domain terminology. Prioritize semantic clar...
Use contextually descriptive names
mastodon/mastodonNames should clearly indicate their purpose and context to avoid confusion, especially when similar concepts exist in...
Optimize database queries
mastodon/mastodonWrite efficient database queries by leveraging proper indexes, using performance-optimized ActiveRecord methods, and ...
early nil validation
mastodon/mastodonCheck for nil values early in methods and handle them gracefully before they can cause runtime errors or trigger expe...
batch similar operations
mastodon/mastodonWhen performing multiple similar operations (database queries, Redis calls, job enqueues, or data lookups), batch the...
API parameter design
mastodon/mastodonDesign API parameters with clear intent, proper validation, and thoughtful default behaviors. Parameter names should ...
Structure documentation effectively
maplibre/maplibre-nativeDocumentation should prioritize clear organization with a logical flow to help developers find information quickly. A...
Self-documenting code naming
maplibre/maplibre-nativeMethod, parameter, and variable names should clearly describe their purpose and behavior, making code self-documentin...
Prefer safe null handling
maplibre/maplibre-nativeUse explicit, safe practices when dealing with potentially null resources to prevent memory leaks and undefined behav...
Document public API completely
maplibre/maplibre-nativeAll public APIs (files in `include/`) must have comprehensive documentation using either Doxygen-style or triple-slas...
optimize algorithm performance
logseq/logseqWhen implementing algorithms, prioritize performance optimization through careful algorithm selection, query structur...
Defer expensive operations
logseq/logseqAvoid performing expensive computations until they are actually needed, and eliminate redundant work in hot code path...
Configuration option lifecycle
logseq/logseqWhen adding new configuration options, follow a systematic approach to ensure consistency and maintainability across ...
API parameter consolidation
lobehub/lobe-chatWhen designing API functions with multiple parameters, consolidate optional or related parameters into a single optio...
Eliminate redundant operations
LMCache/LMCacheAvoid unnecessary function calls, I/O operations, and redundant checks that can significantly impact performance. Loo...
Cache state consistency
LMCache/LMCacheEnsure cache operations maintain consistent state and handle shared resources properly throughout the cache lifecycle...
AI model architecture flexibility
LMCache/LMCacheAvoid hardcoding AI model-specific assumptions and instead design systems to be configurable across different model a...
Use descriptive semantic names
llvm/llvm-projectChoose specific, meaningful names that clearly convey purpose and follow established codebase patterns. Avoid generic...
proper error propagation
llvm/llvm-projectEnsure errors are properly propagated to callers rather than handled locally with exits or fatal errors. Library func...
minimize header dependencies
llvm/llvm-projectOrganize code to minimize header dependencies and improve compilation times. Use forward declarations instead of incl...
Eliminate redundant null checks
llvm/llvm-projectAvoid unnecessary null checks when the called function already handles null cases, and use references instead of poin...
Design thoughtful API interfaces
llvm/llvm-projectWhen designing APIs, prioritize clarity, appropriate abstraction levels, and user experience. Avoid magic numbers or ...
cost-based algorithmic decisions
llvm/llvm-projectWhen implementing algorithmic transformations and optimizations, use cost analysis and profitability heuristics to gu...
use model metadata
ggml-org/llama.cppLeverage model metadata from GGUF format instead of hardcoded configuration values or filename-based logic. Model met...
optimize memory access patterns
ggml-org/llama.cppEnsure CUDA kernels use optimal memory access patterns to maximize performance. This involves several key practices: ...
measure before optimizing
ggml-org/llama.cppAlways profile and measure performance impact before implementing optimizations, especially micro-optimizations. Many...
AI parameter organization
ggml-org/llama.cppEnsure proper organization and placement of AI model parameters, hyperparameters, and configuration options. Avoid pa...
Use configuration helper utilities
BerriAI/litellmAlways use centralized helper functions for configuration management instead of direct environment variable access or...
Prefer generic API patterns
BerriAI/litellmAvoid creating provider-specific API implementations when generic, reusable solutions exist or can be developed. This...
background task coordination
BerriAI/litellmWhen working with background tasks in async applications, ensure proper task lifecycle management and coordination to...
avoid expensive operations
BerriAI/litellmIdentify and optimize resource-intensive operations in frequently executed code paths. This includes avoiding memory-...
API parameter consistency
BerriAI/litellmEnsure consistent parameter naming, format, and usage across all API interfaces, documentation, and code examples. Th...
Validate all inputs
langfuse/langfuseAll user-controlled inputs must be validated and sanitized before use to prevent injection attacks, unauthorized acce...
Use structured logging framework
langfuse/langfuseReplace all console.* calls with an appropriate structured logging framework using proper log levels. This ensures co...
Memoize computed values
langfuse/langfuseCache the results of expensive operations and component renders to avoid redundant calculations during re-renders. Th...
Ensure deterministic query results
langfuse/langfuseAlways ensure database queries produce deterministic results by including explicit ORDER BY clauses when using LIMIT ...
Avoid array mutations
langfuse/langfuseAlways clone arrays before performing operations that would mutate the original array, especially when working with c...
intentional error handling
langflow-ai/langflowMake deliberate, context-appropriate decisions about error handling strategy rather than applying generic patterns. C...
Validate untrusted input
langchain-ai/langchainjsAlways validate and sanitize user-provided inputs before using them in sensitive contexts like SQL queries, file path...
Throw meaningful errors
langchain-ai/langchainjsAlways throw specific, actionable errors instead of returning unexpected values or simply logging issues. Error messa...
Optimize model token usage
langchain-ai/langchainjsImplement token-efficient patterns when working with AI models to optimize costs and performance. Key practices inclu...
Follow documentation standards
langchain-ai/langchainjsEnsure all documentation follows established templates and includes required sections. When referencing components, a...
Prefer early null returns
kubernetes/kubernetesUse early return patterns with null checks to reduce nesting and improve code readability. Avoid unnecessary null che...
Optimize search algorithms
kubernetes/kubernetesImplement efficient search strategies that minimize computational overhead through proper ordering, early termination...
Use modern JavaScript idioms
kubeflow/kubeflowFavor modern JavaScript syntax and clean code practices to improve readability and maintainability. This includes: 1...
Structured documentation with examples
kubeflow/kubeflowCreate comprehensive documentation with clear structure and practical examples. Documentation should include: 1. **S...
Standardize makefile patterns
kubeflow/kubeflowMaintain consistent Makefile patterns across all components to improve build reliability and developer experience in ...
Environment variable management
kubeflow/kubeflowManage environment variables in Docker configurations with appropriate scope, placement, and documentation: 1. **Set...
Centralize configuration values
kubeflow/kubeflowStore all configuration values in dedicated configuration files rather than hardcoding them throughout the applicatio...
Consider operation time complexity
JetBrains/kotlinWhen implementing operations that manipulate collections or perform repeated actions, carefully consider the time com...
optimize algorithmic complexity
apache/kafkaReplace inefficient algorithms with more optimal data structures and approaches to improve computational complexity. ...
Defensive null validation
apache/kafkaAlways validate null parameters and dependencies early with proper ordering to prevent NullPointerExceptions and prov...
API completeness validation
apache/kafkaEnsure APIs are complete by validating that all necessary cases are handled, all required arguments are properly vali...
Use type-specific variable names
jj-vcs/jjUse distinct variable names that reflect their types to avoid confusion and make code intent clearer. Avoid reusing t...
Consistent naming conventions
jj-vcs/jjMaintain consistent naming and terminology throughout code and documentation. This includes proper capitalization of ...
eliminate code redundancy
menloresearch/janRemove duplicate imports, unused legacy code, and repetitive patterns to maintain clean, organized codebases. Extract...
network configuration consistency
istio/istioEnsure network-related configurations remain consistent across different components and avoid unintended overwrites t...
Conservative networking defaults
istio/istioWhen configuring networking components, prefer stable and permissive defaults over restrictive or experimental config...
API compatibility preservation
istio/istioWhen evolving APIs, prioritize backward compatibility and avoid changing the semantics of existing fields. Instead of...
Structured logging best practices
influxdata/influxdbUse structured logging with appropriate field types and context to make logs more useful for troubleshooting. Choose ...
Stable schema identifiers
influxdata/influxdbUse persistent identifiers for schema elements rather than relying on positional information or enumeration, which ca...
Prefer explicit nullability
influxdata/influxdbAlways make nullable states explicit in your code by leveraging Rust's type system. Use `Option
Manage complete cache lifecycle
influxdata/influxdbImplement comprehensive cache lifecycle management focusing on three key aspects: 1. Idempotent Creation: Make cache...
Maintain code readability
influxdata/influxdbEnsure code remains readable and maintainable by following these practices: 1. **Combine case statements with identi...
Handle errors by criticality
influxdata/influxdbChoose error handling strategies based on operation criticality: 1. For critical operations that could corrupt data ...
Descriptive semantic naming
influxdata/influxdbCreate identifiers that clearly convey meaning through descriptive names and appropriate types. Two key practices imp...
Clear configuration parameters
influxdata/influxdbConfiguration parameters should be descriptively named, well documented, and have sensible defaults that are visible ...
Transactional verified migrations
elie222/inbox-zeroEnhance database migration reliability by wrapping changes in transactions with pre-check and post-verification steps...
Time precision matters
elie222/inbox-zeroWhen implementing algorithms involving date and time calculations, maintain precise control over time components to a...
Prevent async race conditions
elie222/inbox-zeroAlways guard against race conditions when working with asynchronous code. Implement these patterns to avoid unpredict...
Names reflect semantic purpose
elie222/inbox-zeroChoose names that reflect the semantic purpose rather than implementation details or temporal characteristics. Names ...
optimize computational efficiency
hyprwm/HyprlandPrioritize algorithmic efficiency and avoid unnecessary computational overhead in performance-critical code paths. Lo...
reduce nesting complexity
helix-editor/helixPrefer code structures that minimize nesting levels and improve readability through early returns, pattern matching, ...
Follow established conventions
helix-editor/helixConfiguration settings should align with official language documentation and established community standards rather t...
Standardize observability semantic conventions
grafana/grafanaWhen implementing observability features (logs, metrics, traces), use consistent semantic conventions to ensure data ...
Proper shell quoting
grafana/grafanaAlways use proper quoting in shell scripts (especially GitHub Actions workflows) to prevent word splitting, globbing,...
Function design principles
grafana/grafanaDesign functions for maximum reusability, clarity, and maintainability. Follow these principles: 1. **Pass complete ...
Close resources with errors
grafana/grafanaAlways close resources (files, streams, connections) and properly handle their Close() errors. For read operations, C...
Verify configuration documentation
block/gooseEnsure all configuration documentation accurately reflects actual system behavior, available options, and correct com...
Use if-unwrap with optionals
ghostty-org/ghosttyAlways use Zig's if-unwrap pattern (`if (optional) |value| {...}`) when working with optional values instead of force...
Use specific configuration patterns
google-gemini/gemini-cliWhen defining exclusion patterns, file filters, or other configuration rules, use specific, targeted patterns rather ...
Never ignore errors silently
google-gemini/gemini-cliAll errors must be explicitly handled through catching, logging, or user feedback. Silent error suppression makes deb...
Maintain naming consistency
google-gemini/gemini-cliEnsure consistent naming patterns and approaches across similar functionality in the codebase. This includes using na...
implement resource constraints
google-gemini/gemini-cliImplement multiple types of resource constraints with appropriate thresholds to prevent performance degradation and r...
document current functionality
google-gemini/gemini-cliDocumentation should focus exclusively on current, active functionality rather than including historical context, dep...
classify errors appropriately
google-gemini/gemini-cliDifferent types of errors require different handling strategies. Classify errors into categories and apply appropriat...
Choose efficient data structures
google-gemini/gemini-cliSelect data structures and algorithms that match your performance requirements rather than defaulting to simple but i...
API consistency patterns
google-gemini/gemini-cliMaintain consistent interface patterns across APIs and avoid loose coupling through magic strings or unstable propert...
add tests for changes
google-gemini/gemini-cliEvery code change, whether it's a new feature, bug fix, or refactoring, must include corresponding tests. This ensure...
Handle errors completely
fatedier/frpAlways handle errors comprehensively by checking return values, implementing proper error propagation, and ensuring r...
Connection lifecycle management
fatedier/frpImplement comprehensive lifecycle management for network connections. Ensure proper initialization, authentication, m...
Manage dependencies wisely
laravel/frameworkWhen configuring dependencies in composer.json files, follow these guidelines to ensure maintainable and reliable con...
Escape column names properly
laravel/frameworkAlways use the appropriate wrapping/escaping mechanism when generating SQL to prevent syntax errors and SQL injection...
Design flexible APIs
laravel/frameworkWhen designing APIs, prioritize flexibility and developer experience by: 1. **Accept broader parameter types** - Use...
Eliminate redundant operations
flutter/flutterIdentify and remove unnecessary operations that impact performance, including redundant checks, duplicate calculation...
Avoid breaking changes
flutter/flutterWhen modifying existing APIs, prioritize backward compatibility to prevent breaking changes that would force develope...
Use structured error logging
firecrawl/firecrawlAlways use the proper logger instance instead of console methods, and format error logs with structured data objects ...
Validate security configurations
gofiber/fiberAlways verify that security middleware configurations use correct constant values, proper parameter specifications, a...
Evaluate nil check necessity
gofiber/fiberBefore adding nil checks, evaluate whether they are actually necessary or if they represent false positives from stat...
Type-safe API designs
fastify/fastifyDesign APIs with strong type safety to improve developer experience and catch errors at compile time. Avoid using any...
Properly Handle Errors in Fastify Applications
fastify/fastifyWhen implementing error handling in Fastify applications, it is important to always throw instances of the Error clas...
Preserve error context
fastify/fastifyWhen handling errors, always ensure the original error context is preserved and properly surfaced. Error information ...
Null safe patterns
fastify/fastifyUse concise null checking patterns to prevent runtime errors and improve code readability when handling potentially u...
Explicit Configuration Usage in Fastify
fastify/fastifyWhen using the Fastify framework in TypeScript, ensure that all configuration options are explicitly declared and pro...
Consistent JSDoc standards
fastify/fastifyDocument all public APIs and significant internal functions with comprehensive JSDoc comments that include accurate d...
Adhere to Fastify Coding Conventions
fastify/fastifyWhen implementing code that uses the Fastify package in TypeScript, ensure the following conventions are followed: av...
Protocol-specific error handling
fastapi/fastapiHandle errors and responses appropriately based on the network protocol being used. Different protocols have differen...
Consistent code examples
fastapi/fastapiMaintain consistent formatting and styling in code examples throughout your NestJS application documentation. This en...
REST principles first
expressjs/expressWhen designing APIs with Express, prioritize proper REST principles and HTTP semantics over convenience. This ensures...
Propagate errors properly
expressjs/expressAlways forward errors to the framework's error handling pipeline instead of swallowing them or handling them inconsis...
Handle streams properly
expressjs/expressWhen transferring data over HTTP, properly implement streaming mechanisms to prevent memory exhaustion and potential ...
Ensure test completion
expressjs/expressTests must properly terminate by following appropriate asynchronous patterns. For asynchronous tests, always invoke t...
maintain API compatibility
evanw/esbuildWhen implementing or extending APIs, preserve compatibility with existing standards and expected behaviors. APIs shou...
Use descriptive consistent names
electron/electronChoose names that are both semantically accurate and consistent with established patterns. Names should clearly conve...
Descriptive error messages
electron/electronError messages should be descriptive, contextual, and self-identifying to aid debugging and user understanding. Inclu...
Prevent redundant operations
elastic/elasticsearchIn distributed database systems, prevent redundant operations that can overload cluster resources. When implementing ...
validate inputs early
duckdb/duckdbValidate function inputs, preconditions, and assumptions as early as possible in the execution flow, preferably durin...
validate inputs comprehensively
duckdb/duckdbEnsure thorough input validation and comprehensive edge case handling in database operations. This includes checking ...
Optimize algorithm complexity
duckdb/duckdbChoose efficient algorithms and data structures to avoid unnecessary computational complexity. Replace manual loops w...
consistent null validation
duckdb/duckdbEnsure null checks and input validation are applied consistently across similar functions and code paths. When one fu...
Test structure and clarity
stanfordnlp/dspyOrganize tests for maximum clarity and maintainability by leveraging pytest features and proper test structure. Split...
reduce nesting levels
stanfordnlp/dspyMinimize nested conditional statements and complex control flow by using early returns, guard clauses, and default va...
prefer nullish coalescing operator
drizzle-team/drizzle-ormUse the nullish coalescing operator (`??`) instead of the logical OR operator (`||`) when you specifically want to pr...
Version annotation in docs
django/djangoAlways include appropriate version annotations when documenting new features or changes in behavior. Use `.. versiona...
Use semantic HTML elements
django/djangoStructure HTML templates using semantically appropriate elements rather than generic containers. Replace non-semantic...
Structure logs effectively
django/djangoWhen implementing logging in your application, structure your log messages and parameters consistently to improve rea...
Preserve error handling context
django/djangoWhen handling exceptions, preserve the original error context and provide clear, actionable error messages. This help...
Graceful API evolution
django/djangoWhen evolving APIs, prioritize backward compatibility and provide clear migration paths. For any significant change: ...
Comments versus docstrings usage
django/djangoChoose between comments and docstrings based on the documentation's purpose and scope. Use docstrings for API-level d...
validate migration data comprehensively
discourse/discourseMigration scripts must thoroughly validate data conditions and handle edge cases to ensure reliable data transformati...
Use modern syntax
discourse/discourseAdopt modern JavaScript and Ember syntax patterns instead of legacy approaches to improve code readability and mainta...
optimize test fixtures
discourse/discourseUse the `fab!` shorthand syntax for creating test fixtures and reuse fabricated objects across tests to improve perfo...
Improve code readability
discourse/discourseStructure code to match logical flow and extract intermediate variables to improve readability. When dealing with mul...
Extract duplicate code
discourse/discourseWhen you notice repeated code patterns, logic blocks, or similar implementations across methods or classes, extract t...
simplify complex logic
langgenius/difyImprove code readability by reducing complexity and nesting through early returns, extracting complex logic into dedi...
HTTP standards compliance
langgenius/difyEnsure API endpoints follow HTTP standards for status codes and method selection. Delete operations should return 204...
Configuration value types
langgenius/difyEnsure configuration values use appropriate types, avoid unnecessary Optional annotations, and maintain consistency i...
Use appropriate synchronization mechanisms
denoland/denoSelect and implement synchronization primitives that match your concurrency requirements and avoid unsafe patterns. C...
avoid panics gracefully
denoland/denoReplace panic-prone operations like `unwrap()` and `expect()` with graceful error handling that provides meaningful f...
avoid implementation detail leakage
denoland/denoAPIs should provide clean abstraction boundaries without exposing internal implementation details or creating unwante...
User-friendly documentation examples
deeplearning4j/deeplearning4jDocumentation should guide users toward best practices through clear examples. Begin with positive patterns before co...
Use logging best practices
deeplearning4j/deeplearning4jAdopt these logging best practices to ensure consistent, efficient, and meaningful logs: 1. **Use Lombok's `@Slf4j` ...
Numerical stability practices
deeplearning4j/deeplearning4jWhen implementing machine learning algorithms, ensure numerical correctness and stability by following these practice...
Descriptive error context
deeplearning4j/deeplearning4jError messages should be specific, descriptive, and include context to help with debugging. Avoid generic messages li...
Thoughtful error handling
cypress-io/cypressImplement error handling that considers recoverability, appropriate logging levels, and prevents redundant operations...
Simplify complex expressions
cypress-io/cypressBreak down complex conditional logic, nested structures, and verbose syntax into smaller, well-named functions or mor...
prefer modern composition patterns
cypress-io/cypressUse Vue 3 Composition API patterns that provide better performance, type safety, and maintainability. Prefer `compute...
Explain non-obvious code
cypress-io/cypressAdd explanatory comments for complex logic, workarounds, and non-obvious code patterns to help future maintainers und...
Environment variable validation
cypress-io/cypressAlways validate environment variables with proper type checking, fallback values, and defensive handling to prevent r...
consistent descriptive naming
cypress-io/cypressMaintain consistent naming patterns across similar functionality while ensuring names accurately describe their curre...
Configuration documentation clarity
cypress-io/cypressEnsure configuration documentation, setup instructions, and changelogs use precise, clear language with proper techni...
Model-agnostic AI code
crewaiinc/crewaiWhen building applications that interact with AI models, avoid hardcoding model-specific behavior and instead design ...
prefer None over placeholders
home-assistant/coreWhen data is unavailable, unknown, or invalid, return `None` instead of placeholder strings like "Unknown", "Unspecif...
Minimize try block scope
home-assistant/coreOnly include code that can actually raise exceptions within try blocks. Move variable assignments, logging statements...
Maintain consistent code style
vuejs/coreFollow project-wide code style conventions to ensure consistency and readability. Key practices include: 1. Use cons...
Explicit nullish checks
vuejs/coreWhen checking for the absence of values, use explicit nullish checks rather than relying on JavaScript's falsy behavi...
Validate before data access
continuedev/continueAlways validate data existence and type before accessing properties or methods to prevent runtime errors from null/un...
Standardize AI model interfaces
continuedev/continueWhen implementing AI model integrations, maintain consistent interfaces and proper type definitions across different ...
Robust comparison algorithms
continuedev/continueEnsure your comparison algorithms handle edge cases properly and avoid common pitfalls: 1. **Normalize values before...
Document why not what
continuedev/continueDocumentation should explain rationale and be technically precise. Focus on: 1. Including all required parameters wi...
Decouple tests from implementation
continuedev/continueTests tightly coupled to implementation details break easily when the implementation changes, creating maintenance bu...
Choose clear semantic names
continuedev/continueNames should clearly and accurately convey their purpose, behavior, and content. Follow these guidelines: 1. Use pos...
Scope concurrency control precisely
docker/composeApply concurrency control mechanisms with precise scope to prevent both race conditions and unnecessary blocking. Use...
prefer dynamic configuration sources
comfyanonymous/ComfyUIUse runtime-determined configuration sources instead of hardcoded values or static file parsing when more reliable al...
optimize CI resource usage
comfyanonymous/ComfyUIDesign CI/CD workflows to minimize unnecessary resource consumption and provide faster feedback. Avoid triggering bui...
Explicit error propagation
comfyanonymous/ComfyUIFunctions should raise exceptions with meaningful messages instead of returning False, None, or silently catching all...
avoid expensive operations
comfyanonymous/ComfyUIIdentify and eliminate unnecessary expensive operations that can significantly impact performance. Common patterns to...
API backward compatibility
comfyanonymous/ComfyUIEnsure API changes maintain backward compatibility to avoid breaking existing clients and workflows. When adding new ...
Write comprehensive test assertions
openai/codexInstead of making multiple small assertions that check individual fields or conditions, write single comprehensive as...
Structure configurations properly
openai/codexDefine a clear, hierarchical structure for application configurations with descriptive naming and proper organization...
Document non-obvious aspects
openai/codexDocumentation should explain what isn't obvious from the code itself. Focus on providing context about "why" certain ...
Contextualize, don't swallow
openai/codexAlways propagate errors with appropriate context rather than silently ignoring them. This makes debugging easier and ...
Centralize configuration management
openai/codexPrefer centralized configuration objects over environment variables for application settings. Environment variables c...
use semantic naming
cline/clineChoose variable, function, and type names that clearly communicate their purpose and meaning without requiring additi...
reuse common message types
cline/clinePrefer reusable message types over single-purpose request/response pairs to reduce API bloat and improve maintainabil...
centralize configuration management
cline/clineConsolidate related configuration settings into dedicated config objects or files rather than scattering hardcoded va...
Add missing error handling
cline/clineWrap operations that can fail in try/catch blocks to prevent unhandled exceptions from crashing the application or le...
optimize algorithmic complexity
ClickHouse/ClickHouseAlways consider the algorithmic complexity and performance implications of data structure choices, memory allocation ...
optimize algorithm selection
ClickHouse/ClickHouseChoose algorithms and data structures based on actual performance characteristics rather than defaulting to standard ...
Extract common patterns
ClickHouse/ClickHouseIdentify and extract repeated code patterns into reusable functions or methods to improve maintainability and reduce ...
Database schema consistency
ClickHouse/ClickHouseEnsure database operations maintain consistent behavior and ordering, especially in distributed systems. When working...
Use optional chaining
snyk/cliAlways use optional chaining (`?.`) and null checks when accessing properties or methods on objects that might be nul...
comprehensive test coverage
snyk/cliEnsure thorough test coverage by extracting complex logic into small, testable functions and using appropriate testin...
Secure credential management
chef/chefWhen handling passwords, certificates, or keys in your code, implement secure encryption and storage mechanisms to pr...
Prefer guard clauses
chef/chefUse guard clauses with early returns for null checking instead of wrapping code in conditional blocks. This improves ...
Explicit configuration over implicit
chef/chefAlways define explicit configuration defaults rather than relying on implicit behavior or autovivification. Configura...
Use appropriate logging levels
bridgecrewio/checkovSelect the correct logging level based on the importance and visibility requirements of the information. Choose WARNI...
Thorough test assertions
bridgecrewio/checkovEnsure tests thoroughly validate functionality through comprehensive assertions. When writing tests: 1. Assert all r...
Strategic exception management
bridgecrewio/checkovChoose the appropriate error handling strategy based on the context and severity of potential failures. Use exception...
Strategic error handling
bridgecrewio/checkovChoose appropriate error handling strategies based on the nature of the error and recovery potential: 1. **Raise exc...
Document configuration options
bridgecrewio/checkovAlways provide comprehensive documentation for all configuration options, including environment variables, feature fl...
Choose optimal data structures
bridgecrewio/checkovSelect the most appropriate data structure based on the specific operations your algorithm needs to perform. This cho...
Use descriptive identifiers
calcom/cal.comChoose specific, descriptive names for variables, functions, and parameters that clearly communicate their purpose an...
Explicit null checks
calcom/cal.comAlways use explicit null and undefined checks instead of relying solely on optional chaining, especially when you nee...
ensure test reliability
calcom/cal.comWrite tests that are stable, independent, and non-flaky by following proper isolation and waiting practices. Tests sh...
Design contextual API interfaces
calcom/cal.comAPI interfaces should expose only relevant data and functionality based on context, configuration, and user requireme...
Use memory pools
oven-sh/bunReuse memory with buffer pools for temporary allocations instead of creating new buffers each time. This reduces memo...
Network API compatibility
oven-sh/bunWhen implementing networking APIs that mirror Node.js functionality, ensure both behavior and error patterns match No...
Match filenames to contents
oven-sh/bunFiles should be named to clearly reflect their primary contents: 1. When a file contains a single primary type: -...
Descriptive identifier names
oven-sh/bunChoose clear, consistent, and accurate identifiers that precisely reflect behavior and follow established patterns. T...
Clean all error paths
oven-sh/bunEnsure all error paths properly clean up resources and handle errors appropriately. This includes: 1. Using errdefer...
Environment variable configuration
browser-use/browser-usePrefer environment variables over hardcoded configuration values to improve flexibility and avoid forcing configurati...
Simplify complex code blocks
Homebrew/brewBreak down complex code blocks and expressions into simpler, more readable components. Complex boolean logic, nested ...
Actions workflow best practices
Homebrew/brewUse GitHub Actions native features and follow best practices to create maintainable, secure, and reliable CI workflow...
Write clear examples
boto/boto3Create comprehensive code examples in documentation that demonstrate common operations and use proper formatting. Use...
Consistent method interfaces
boto/boto3Design APIs with consistent method interfaces across related resources to improve usability and reduce learning curve...
Configure proxies with schemes
boto/boto3When configuring proxies in AWS SDK clients, always include the complete URL scheme in proxy definitions. Match the s...
Validate before usage
better-auth/better-authAlways explicitly check for null or undefined values before using them in operations. Don't assume values exist - val...
Prefer simple solutions
better-auth/better-authChoose existing utilities, simpler patterns, and cleaner implementations over manual or complex approaches. This impr...
Use semantically clear names
bazelbuild/bazelChoose names that clearly express their purpose and avoid patterns that can lead to confusion or bugs. Names should b...
Specific exceptions for clarity
Azure/azure-sdk-for-netUse specific exception types with meaningful error messages rather than generic exceptions to improve error handling,...
Preserve API compatibility
Azure/azure-sdk-for-netWhen evolving APIs, maintain backward compatibility to prevent breaking changes for existing consumers. Key approac...
Maintain clean code structure
Azure/azure-sdk-for-netKeep code clean and well-organized by: 1. Removing unnecessary elements: - Delete commented-out code that is no lo...
Centralize configuration values
Azure/azure-sdk-for-netConfiguration values should be defined once and referenced throughout your project to ensure consistency and simplify...
Prefer descriptive over brief
tokio-rs/axumChoose clear, descriptive names over abbreviated or shortened versions. Names should be self-documenting and follow R...
Documentation consistency standards
tokio-rs/axumMaintain consistent documentation formatting standards across all project files, especially in changelogs, code examp...
Consistent axum Usage in TypeScript
tokio-rs/axumWhen implementing TypeScript code that uses the axum package, maintain consistent and idiomatic usage: always use low...
Type-safe API interfaces design
axios/axiosDesign API interfaces with strong type safety while maintaining excellent developer experience. Prefer explicit types...
Standardize null value checks
axios/axiosAlways use consistent patterns and utility functions for handling null and undefined values. This improves code relia...
Specific test assertions
axios/axiosWhen writing tests, explicitly assert specific conditions and expected values rather than relying on general success/...
Proxy protocol handling
axios/axiosWhen implementing HTTP clients with proxy support, ensure the connection to the proxy uses the protocol specified in ...
Documentation reflects reality
axios/axiosAlways ensure documentation accurately represents the actual code behavior and implementation details. Include import...
Consistent method behaviors
axios/axiosDesign API methods with predictable behavior patterns that follow common conventions. Methods that modify objects dir...
Complete error handling chain
axios/axiosImplement comprehensive error handling throughout the codebase by ensuring all error scenarios are properly caught, t...
Structured test resource management
aws/aws-sdk-jsOrganize tests with proper resource lifecycle management to ensure reliability and maintainability. Create test resou...
Content integrity verification
aws/aws-sdk-jsWhen handling HTTP responses, especially with streaming data, properly verify content integrity and length to prevent...
Use descriptive constants
argoproj/argo-cdReplace hardcoded strings, numbers, and magic values with well-named constants that clearly describe their purpose an...
Use configuration constants
argoproj/argo-cdReplace hardcoded values with named constants from common packages or make values configurable through environment va...
structured logging practices
argoproj/argo-cdUse structured logging with proper context and consolidate related log messages. Instead of multiple separate log sta...
Provide comprehensive explanations
argoproj/argo-cdDocumentation should provide thorough technical explanations that define key concepts, explain behaviors, and include...
Follow Go naming conventions
argoproj/argo-cdAdhere to Go naming conventions and maintain consistency with established codebase terminology. This includes proper ...
Choose appropriate synchronization primitives
argoproj/argo-cdSelect the right synchronization mechanism based on your specific use case to avoid performance regressions and ensur...
Check nil before access
argoproj/argo-cdAlways verify that pointers and nested struct fields are not nil before accessing their members to prevent runtime pa...
Assert response fully always
appwrite/appwriteAlways validate all relevant aspects of API responses in tests, including status codes, headers, and body content. Do...
Simplify complex expressions
ant-design/ant-designExtract repeated expressions and complex conditional logic into clear, readable variables to improve code maintainabi...
Semantic naming consistency
ant-design/ant-designChoose semantically clear and consistent names across related elements in your codebase. Names should convey their pu...
React component API clarity
ant-design/ant-designEnsure React component APIs are well-designed with accurate TypeScript interfaces, clear documentation, and intuitive...
Extract common patterns
ant-design/ant-designWhen you encounter repeated code patterns, conditional logic within loops, or similar implementations across componen...
Consistent null safety patterns
ant-design/ant-designMaintain consistent approaches to null and undefined handling throughout the codebase. Use optional chaining (`?.`) f...
Configuration documentation standards
ant-design/ant-designEnsure configuration properties and settings are documented with consistent formatting and precise specifications. Co...
avoid redundant operations
angular/angularIdentify and eliminate redundant computations, function calls, and expensive operations that can be cached, memoized,...
API consistency patterns
angular/angularEnsure that similar APIs follow consistent patterns and conventions across the codebase. When designing or modifying ...
AI documentation clarity
angular/angularEnsure AI-related documentation, comments, and explanations are clear, accurate, and well-structured. This includes f...
Add explanatory comments
angular/angularCode should include explanatory comments when the purpose, behavior, or context is not immediately clear from reading...
Write audience-appropriate documentation
alacritty/alacrittyDocumentation should be written from the perspective of its intended audience, using language and detail levels appro...
prefer early returns
alacritty/alacrittyUse early returns and guard clauses to reduce nesting levels and improve code readability. When you have multiple con...
Configuration validation feedback
alacritty/alacrittyAlways validate configuration options and provide clear feedback to users about potential issues. This includes warni...
Configuration documentation accuracy
alacritty/alacrittyEnsure configuration documentation is accurate, consistent, and clearly indicates optional versus required values. Us...
Avoid unwrap on nullables
alacritty/alacrittyNever use `unwrap()` on nullable values that could reasonably be None, as this can cause crashes that are harder for ...
avoid unnecessary operations
alacritty/alacrittyEliminate redundant work by implementing early returns, avoiding unnecessary clones/references, and skipping computat...
Validate nulls explicitly
apache/airflowAlways check for null values before using them, and use Python's idiomatic patterns to make these checks concise and ...
Use system configuration defaults
apache/airflowAlways use the configuration system's default values instead of hardcoding defaults in the code. This ensures consist...
Maintain code consistency
apache/airflowEnsure consistency throughout the codebase by following established patterns for both UI components and code structur...
Internationalize ui text
apache/airflowAll user interface text must be internationalized using the appropriate i18n module instead of hardcoded strings. Thi...
Handle exceptions with specificity
apache/airflowUse specific exception types and avoid masking errors through overly broad exception handling or default values. This...
Documentation best practices
apache/airflowDocumentation should follow established best practices to ensure clarity, consistency, and usefulness: 1. **Use prop...
Verify properties before logging
vercel/aiWhen logging object properties, always verify that the property names exactly match the actual structure of the objec...
Maintain API naming consistency
vercel/aiWhen working with AI model interfaces and result objects, ensure consistent property naming across related components...
Document API schemas
vercel/aiAdd comprehensive JSDoc comments to all API interfaces, types, and schema definitions. This documentation should: 1....
Consistent provider options
vercel/aiWhen designing APIs that support multiple providers or service integrations, implement consistent patterns for handli...
Protect render loop performance
zed-industries/zedEnsure render loop operations stay within frame time budget (typically 16.67ms for 60fps). Avoid expensive computatio...
Contextualize don't panic
zed-industries/zedAlways provide meaningful context for errors and avoid code that can panic in production. Use `.context()` or `.with_...
Background process blocking operations
zed-industries/zedAlways move potentially blocking operations to background threads to maintain UI responsiveness. Use appropriate spaw...
standardize build configurations
facebook/yogaEnsure build configurations are consistently propagated through all build steps and output directories follow standar...
optimize memory layout
facebook/yogaPrioritize memory-efficient data structures and algorithms by favoring stack allocation over heap allocation, utilizi...
Improve code readability
facebook/yogaEnhance code clarity and maintainability by applying several readability techniques: extract repeated expressions int...
explicit code declarations
facebook/yogaAlways make code declarations explicit and consistent to improve readability and maintainability. This includes speci...
Evaluate synchronization necessity
facebook/yogaBefore implementing thread safety mechanisms like atomic operations or mutexes for global variables, critically asses...
Simplify conditional logic
cloudflare/workers-sdkPrefer concise conditional expressions over verbose nested conditions and unnecessary boolean variables. This improve...
ensure test isolation
cloudflare/workers-sdkTests must be isolated and not leak state between runs. This includes properly cleaning up mocks, spies, and any glob...
changeset validation standards
cloudflare/workers-sdkEstablish comprehensive validation for changesets to ensure reliable release automation. Changesets are required for ...
HTTP protocol compliance
cloudflare/workerdEnsure HTTP protocol implementations strictly follow RFC standards and handle edge cases correctly. This includes pro...
Connection reuse safety
cloudflare/workerdWhen implementing network connection reuse, prioritize safety over performance by enforcing sequential request patter...
Add explanatory comments
cloudflare/workerdWhen code behavior, limitations, or implementation decisions are not immediately obvious from reading the code itself...
Validate before expensive operations
microsoft/vscodePerform lightweight validation checks before executing expensive operations to avoid unnecessary resource consumption...
Optimize algorithmic complexity first
microsoft/vscodeWhen implementing algorithms, prioritize reducing computational complexity before adding special cases or optimizing ...
Handle configuration value changes
microsoft/vscodeConfiguration values should be properly initialized and stay updated throughout their lifecycle. Follow these guideli...
Comprehensive test structure
volcano-sh/volcanoTests should focus on comprehensive coverage of main logic flows rather than trivial functions, use established testi...
Always check errors
volcano-sh/volcanoAlways check and handle errors returned from function calls, especially API operations, before proceeding with subseq...
Document AI model capabilities
vllm-project/vllmProvide clear, comprehensive documentation for AI model capabilities, especially for multimodal features and deployme...
Use parameterized queries
vitessio/vitessAlways use parameterized queries with bind variables instead of string concatenation or formatting when constructing ...
Standardize error wrapping patterns
vitessio/vitessUse consistent error wrapping patterns to preserve error context and ensure proper error code propagation. Always: 1....
Metric design best practices
vitessio/vitessDesign metrics to be reliable and maintainable by following these key principles: 1. Initialize metrics with zero va...
Log levels and clarity
vitessio/vitessChoose appropriate log levels and write clear, meaningful log messages that provide necessary context without creatin...
Explicit nil handling
vitessio/vitessAlways handle nil values explicitly in your code to improve clarity and prevent subtle bugs. When a function needs to...
Environment-portable configuration management
vitessio/vitessEnsure all configurations are environment-portable and follow current best practices for the target platforms. This i...
Use optional patterns
vitejs/viteChoose the most appropriate pattern for handling potentially undefined or null values. When designing types, prefer o...
Optimize glob operations
vitejs/viteWhen using glob patterns for file system operations, ensure optimal performance and consistent behavior by configurin...
Minimize memory allocations
vitejs/viteChoose methods and patterns that reduce unnecessary memory allocations and object creation to improve performance. Wh...
Manage configuration inheritance carefully
vitejs/viteWhen designing configuration systems, establish clear default values and inheritance patterns. Follow these principle...
Leverage native tooling
vitejs/vitePrioritize native or Rust-based implementations of build tools over their JavaScript counterparts to significantly im...
Evolve APIs with compatibility
vitejs/viteWhen evolving APIs, maintain backwards compatibility while introducing new features by following a staged deprecation...
Document code purposefully
vitejs/viteHigh-quality code documentation improves maintainability and helps other developers understand your intentions. Follo...
Clean configuration organization
vitejs/viteOrganize configuration settings logically and avoid redundancy in project configuration files. Group related options ...
Break down complex functions
vitejs/viteImprove code readability and maintainability by decomposing large, complex functions into smaller, focused ones. When...
explicit null checks
vlang/vAlways verify that pointers and function return values are not null before dereferencing or using them. This prevents...
Document algorithm behavior
vlang/vWhen implementing or documenting algorithms, clearly specify their behavior, expected outputs, and usage patterns. Th...
Configure socket blocking behavior
vlang/vAlways explicitly configure socket blocking behavior when creating TCP connections, and provide compile-time flags fo...
Use direct documentation style
astral-sh/uvWrite documentation using direct, clear language that addresses the reader directly. Follow these style guidelines: ...
Respect connectivity state
astral-sh/uvApplications should gracefully handle different network connectivity states and provide appropriate feedback to users...
Consistent authentication patterns
astral-sh/uvDesign API authentication mechanisms with consistent patterns, clear documentation, and helpful error messages. When ...
Balance test performance considerations
astral-sh/uvWhen writing tests, consider both thoroughness and execution time. For operations with significant overhead (like Pyt...
optimize algorithmic complexity
Unstructured-IO/unstructuredWhen implementing algorithms, prioritize performance by avoiding unnecessary computations and choosing efficient appr...
Document configuration reasoning
Unstructured-IO/unstructuredAlways document the reasoning behind configuration decisions, especially for temporary settings like dependency pins,...
Database schema compliance
Unstructured-IO/unstructuredEnsure database integrations use correct field names, data types, and schema conventions specific to each database sy...
workspace dependency consistency
unionlabs/unionAll internal project dependencies should use workspace configuration instead of direct path or git references to ensu...
Validate before type conversions
unionlabs/unionAlways validate input constraints and use safe conversion methods before performing type conversions that could fail ...
Use structured logging fields
unionlabs/unionPrefer structured logging fields over string formatting in tracing logs to improve searchability, parsing, and consis...
Effect-based API clients
unionlabs/unionUse Effect-based HTTP clients with specific error types instead of throwing generic exceptions or relying on third-pa...
Configuration file completeness
unionlabs/unionEnsure all configuration files contain required fields, maintain proper structure, and follow consistent formatting s...
API interface design
unionlabs/unionDesign APIs with clean abstractions, logical data organization, and proper layer separation. Structure interfaces to ...
React rendering safeguards
shadcn-ui/uiThis standard ensures your React components render correctly and efficiently, preventing common pitfalls that cause e...
Provide actionable errors
microsoft/typescriptError messages should not only identify problems but also guide developers toward solutions. Include specific steps, ...
Preserve API compatibility first
microsoft/typescriptWhen modifying existing APIs, maintain backwards compatibility by adding new overloads rather than directly changing ...
Consistent type algorithms
microsoft/typescriptImplement consistent algorithms for type compatibility and comparison across different data structures. When developi...
Cache expensive computed values
microsoft/typescriptCache frequently accessed or computed values to avoid redundant calculations and property lookups. This applies to: 1...
API documentation clarity
astral-sh/tyEnsure API documentation, including changelogs and feature descriptions, prioritizes user understanding over implemen...
Validate configuration consistency
twentyhq/twentyEnsure configuration values have consistent defaults across all systems and validate configuration structures using s...
Avoid expensive repeated operations
twentyhq/twentyIdentify and eliminate expensive operations that are performed repeatedly, such as object creation in loops, redundan...
Keep build tooling updated
vercel/turborepoMaintain up-to-date build and CI/CD tooling to leverage the latest features, performance improvements, and security p...
Define API boundaries
vercel/turborepoClearly specify what constitutes your public API contract to manage versioning expectations and documentation require...
Configuration precision matters
vercel/turborepoEnsure configuration files are precise and stable to prevent unexpected build failures and runtime issues. This inclu...
Choose logging levels wisely
vercel/turborepoSelect appropriate logging levels based on the frequency and importance of the logged operation. Use `trace` for high...
Boundary case handling
vercel/turborepoAlways handle boundary conditions explicitly in algorithms to prevent unexpected behavior. When implementing algorith...
validate algorithm boundaries
tree-sitter/tree-sitterAlways validate boundary conditions and termination criteria in algorithms to prevent infinite loops, out-of-bounds a...
Use meaningful prefixed names
tree-sitter/tree-sitterNames should be semantically meaningful and properly prefixed to prevent namespace conflicts. In C, enum variants and...
Simplify conditional logic
tree-sitter/tree-sitterImprove code readability by simplifying complex conditional expressions and control flow structures. Factor out repea...
Respect environment overrides
tree-sitter/tree-sitterBuild systems and configuration scripts must respect standard environment variables and provide proper override mecha...
Provide clear error context
tree-sitter/tree-sitterAlways provide meaningful, specific error messages that help users understand what went wrong and why. Use descriptiv...
parameter type clarity
tree-sitter/tree-sitterDesign API parameters using specific, intention-revealing types rather than generic or ambiguous ones. This improves ...
Optimize CI workflow syntax
tree-sitter/tree-sitterWrite cleaner and more maintainable CI/CD workflows by following established syntax patterns and best practices. Use ...
Conditional compilation guards
tree-sitter/tree-sitterAlways use appropriate preprocessor directives to guard platform-specific, version-dependent, or feature-specific cod...
validate input sanitization
traefik/traefikAlways maintain input sanitization and validation mechanisms to prevent security vulnerabilities. Disabling built-in ...
Network information extraction
traefik/traefikWhen extracting network information from connections (such as remote addresses, proxy IPs, or forwarded headers), imp...
API interface simplification
traefik/traefikDesign APIs with clean, minimal interfaces that encapsulate internal logic and avoid exposing unnecessary complexity ...
Secure unsafe code
tokio-rs/tokioWhen working with unsafe code, follow these practices to minimize security vulnerabilities: 1. **Minimize scope**: L...
Optimize algorithmic efficiency
tokio-rs/tokioPay careful attention to operations inside loops and recursive functions to avoid unexpected algorithmic complexity. ...
Memory ordering needs justification
tokio-rs/tokioWhen using atomic operations, explicitly justify the choice of memory ordering. Each use of a memory ordering should ...
Granular feature flags
tokio-rs/tokioFeature flags should be designed with granularity to ensure dependencies are only required when absolutely necessary....
Document null safety assumptions
tokio-rs/tokioWhen writing code that handles potentially null, undefined, or uninitialized values, always document safety assumptio...
Code block formatting standards
tokio-rs/tokioWhen documenting code examples and shell commands in project documentation, follow these formatting standards to ensu...
Prefer explicit API design
huggingface/tokenizersWhen designing APIs, favor simple and explicit interfaces over flexible but complex ones. This reduces cognitive load...
Choose semantically clear identifiers
huggingface/tokenizersSelect parameter and method names that accurately describe their purpose and behavior, avoiding ambiguous terms that ...
Choose optimal data structures
huggingface/tokenizersSelect data structures based on their algorithmic complexity and usage patterns. Consider the tradeoffs between diffe...
Resource cleanup on errors
hashicorp/terraformAlways ensure proper resource cleanup in error paths to prevent leaks. Use defer functions with explicit error checki...
Explicit protocol interfaces
hashicorp/terraformDesign protocol interfaces with explicit behavior definitions rather than relying on implicit conventions. Clearly sp...
Ensure test isolation
hashicorp/terraformTests should be completely isolated from each other and clean up after themselves to prevent interference. 1. **Use...
Consistent documentation formatting
hashicorp/terraformMaintain consistent style in documentation files to improve readability and professionalism. Specifically: 1. **Comm...
Configuration override precedence
hashicorp/terraformWhen designing systems with configurations that can be specified at multiple levels (global vs local, environment vs ...
Clarify test documentation
hashicorp/terraformEnsure all testing-related documentation is clear, accurate, and user-focused. Use precise terminology when describin...
Choose appropriate API types
hashicorp/terraformSelect the simplest data types that satisfy requirements when designing API signatures. Avoid using complex types (li...
Validate before configuration generation
microsoft/terminalAlways validate system capabilities and existing configuration state before generating new configuration entries or p...
Safe optional handling
microsoft/terminalAlways use safe patterns when working with optional, nullable, or potentially empty types. Avoid direct comparisons w...
Safe null handling patterns
microsoft/terminalAlways use consistent and safe patterns when dealing with potentially null or undefined values. This includes using s...
Reuse defined resources consistently
microsoft/terminalAlways reuse existing defined constants, resources, and reusable components instead of duplicating values or creating...
Minimize reference counting overhead
microsoft/terminalAvoid unnecessary reference counting operations that can impact performance, especially in frequently called code pat...
Implement defensive validation
microsoft/terminalAlways validate inputs, check boundaries, and avoid relying on undocumented API behavior or assumptions about how fun...
API parameter explicitness
microsoft/terminalAlways use correct and explicit parameters when calling APIs, rather than relying on defaults or passing incorrect va...
Tensor-aware control flow
tensorflow/tensorflowWhen working with TensorFlow tensors, avoid using Python comparison operators (`<`, `>=`, `==`) or conditional checks...
Complete docstring structure
tensorflow/tensorflowFunction documentation should follow a consistent structure that includes all necessary components to be complete and...
Centralize configuration settings
tensorflow/tensorflowPlace configuration settings in centralized, appropriate locations rather than duplicating them across multiple files...
Trust GetX accessors
temporalio/temporalWhen working with protocol buffer messages or similar objects that provide GetX() accessor methods, avoid redundant n...
Safe lock usage patterns
temporalio/temporalFollow these critical patterns when using locks to prevent deadlocks, resource leaks, and performance issues: 1. Use...
Ensure deterministic execution
temporalio/temporalWhen working with Temporal workflows, maintaining deterministic behavior is critical for reliable replay and executio...
Dynamic config usage principles
temporalio/temporalUse dynamic configuration selectively and effectively by following these principles: 1. Only use dynamic config for ...
Consistent naming patterns
temporalio/temporalMaintain consistent naming patterns across related components and services. When implementing equivalent functionalit...
Synchronization primitive selection
gravitational/teleportChoose appropriate synchronization primitives and ensure proper protection of shared state to avoid race conditions a...
prefer simpler patterns
gravitational/teleportChoose simpler, more readable code patterns over complex alternatives to improve maintainability and reduce cognitive...
Optimize computational complexity
gravitational/teleportAlways analyze the computational complexity of algorithms and choose efficient implementations to avoid performance b...
Authenticated health checks
gravitational/teleportWhen implementing health checks for external services, verify the complete communication stack rather than just basic...
Add contextual logging
gravitational/teleportAdd informative log messages with sufficient context to help operators diagnose issues, understand system state, and ...
Mathematical precision matters
tensorflow/swiftWhen implementing mathematical algorithms, ensure precise terminology and correct implementation of mathematical conc...
Document environment variables
tensorflow/swiftWhen using configurable components, clearly document all relevant environment variables and their effects. Include ex...
state boundary management
sveltejs/svelteEnsure proper state management when passing reactive values across component and function boundaries. State reactivit...
Simplify and deduplicate code
sveltejs/svelteWrite concise, non-redundant code by eliminating unnecessary duplication and using simpler syntax where possible. Thi...
Documentation clarity standards
sveltejs/svelteEnsure technical documentation clearly distinguishes between similar but different concepts, uses precise language, a...
Complete code examples
sveltejs/svelteEnsure all code examples are complete, functional, and accurately demonstrate the intended concepts. Code examples sh...
API flexibility balance
sveltejs/svelteWhen designing APIs, carefully balance simplicity for common use cases with flexibility for advanced scenarios. Consi...
Secure authentication flows
supabase/supabaseDesign APIs with secure authentication flows by following proper error handling and documentation practices. Avoid no...
Protect sensitive API keys
supabase/supabaseNever expose keys with elevated privileges (such as `service_role` or secret keys) in client-side code. These keys ca...
Pin dependency versions
supabase/supabaseAlways specify exact versions for dependencies in your configuration files and import statements to ensure consistent...
Maintain network controls
supabase/supabaseCreate maintainable and clearly documented network access controls. Instead of hardcoding network restrictions, use d...
Maintain code consistency
supabase/supabaseEnsure consistent code organization, naming conventions, and structure throughout the codebase: 1. Use identical par...
Handle external operations safely
supabase/supabaseAlways implement explicit error handling for external operations such as network requests, database queries, and API ...
Follow hooks rules
supabase/supabaseAdhere strictly to React hooks rules and best practices to ensure your components behave correctly and predictably. C...
Document intent clearly
supabase/supabaseAdd clear documentation that explains not just what code does, but why certain approaches were chosen. This applies t...
organize code properly
browserbase/stagehandMaintain clear code organization by placing code in appropriate files, directories, and modules. Respect module bound...
API parameter design
browserbase/stagehandDesign API methods with structured object parameters instead of ordered parameters or loose typing. Use proper TypeSc...
Use environment-independent defaults
spring-projects/spring-frameworkWhen designing configuration options, avoid relying on environment-specific defaults such as system character encodin...
Spring annotation best practices
spring-projects/spring-frameworkWhen working with Spring annotations, follow these guidelines to avoid common issues: 1. **Use interface types for d...
Minimize lock contention
spring-projects/spring-frameworkWhen implementing thread-safe code, minimize the scope and duration of locks to reduce contention and improve perform...
Consistent style conventions
spring-projects/spring-frameworkApply consistent formatting and organization conventions throughout the codebase to enhance readability and maintaina...
Explicit security documentation
spring-projects/spring-bootAlways provide explicit and accurate documentation for security-related configurations, including: 1. Use proper con...
Session-specific configuration access
apache/sparkAlways access configuration through the appropriate session context rather than using global configuration access. Th...
self-documenting code practices
apache/sparkWrite code that explains itself through clear structure and meaningful names, while adding targeted comments only whe...
Resource cleanup responsibility
apache/sparkEnsure proper resource management by clearly defining cleanup responsibilities and implementing robust cleanup patter...
Externalize configuration values
apache/sparkAvoid hardcoding configuration values directly in code. Instead, make them externally configurable through appropriat...
avoid null in Scala
apache/sparkAvoid using null values in Scala code and prefer Option types for representing optional values. Null usage can lead t...
Use existing API utilities
SigNoz/signozAlways leverage existing utility hooks, constants, and navigation methods instead of implementing manual solutions. T...
REST API conventions
SigNoz/signozFollow standard REST API conventions for HTTP methods, status codes, endpoint structure, and response completeness. U...
ensure migration idempotency
SigNoz/signozDatabase migrations must be designed to run safely multiple times without causing errors or data corruption. This inv...
Avoid inline styles
SigNoz/signozMove all inline styles to dedicated CSS/SCSS files to improve maintainability, consistency, and separation of concern...
Verify algorithmic correctness
sgl-project/sglangEnsure algorithmic implementations are correct before applying optimizations or complex conditional logic. This is es...
Use Optional types safely
sgl-project/sglangAlways use proper nullable type annotations and safe access patterns to prevent runtime errors from null/undefined va...
Prevent race conditions
sgl-project/sglangEnsure atomic operations and proper synchronization when multiple threads or processes access shared state. Race cond...
Optimize cache performance
sgl-project/sglangPrioritize cache performance by leveraging proven optimization techniques and avoiding performance anti-patterns. Use...
standardize log output methods
serverless/serverlessUse `process.stdout.write` instead of `console.log` for controlled logging output to avoid linter issues and ensure c...
Use semantically meaningful names
oraios/serenaChoose names that clearly convey purpose and intent rather than generic or ambiguous terms. Prefer specific, descript...
Use proper logging practices
oraios/serenaAlways use logging instead of print statements, and choose appropriate log levels to avoid log spam. Print statements...
explicit None handling
oraios/serenaWhen operations cannot complete successfully or return meaningful results, explicitly return None rather than raising...
Exception chaining practices
oraios/serenaAlways use exception chaining with `raise ... from e` when re-raising or wrapping exceptions to preserve the original...
Ensure complete documentation quality
oraios/serenaDocumentation should be comprehensive, clear, and provide all necessary context for understanding and using the code ...
Thread management best practices
getsentry/sentryWhen working with threads or thread pools in concurrent code, follow these practices to improve reliability and debug...
Raise contextual error types
getsentry/sentryAlways raise specific, contextual exception types instead of generic exceptions. Include relevant error details that ...
Precise dependency versioning
getsentry/sentry-phpWhen specifying dependency version constraints in configuration files, be deliberate about minimum versions based on ...
Include practical examples
getsentry/sentry-phpEnhance technical documentation with clear, practical code examples that demonstrate usage. This applies to: 1. Chan...
Flexible configuration formats
getsentry/sentry-phpSupport multiple configuration formats where appropriate (string, callable, object) to accommodate different framewor...
Balance CI test coverage
getsentry/sentry-phpConfigure CI workflows to optimize both comprehensive testing and resource usage. For resource-intensive tests that m...
Optimize React hook patterns
getsentry/sentryDesign React hooks with performance and maintainability in mind by following these key principles: 1. Minimize useEf...
Explicit optional type declarations
getsentry/sentryAlways explicitly declare optional types in interfaces and function parameters rather than relying on runtime checks ...
validate environment variable usage
semgrep/semgrepAlways validate environment variables with proper fallback logic and avoid unnecessary usage in tests or when default...
Use appropriate log levels
semgrep/semgrepChoose log levels based on the intended audience to prevent user-visible noise. Most logging should use `Logs.debug` ...
Simplify complex logic
semgrep/semgrepBreak down complex code structures into simpler, more readable forms. Long indented blocks, verbose conditionals, and...
Document configuration choices
semgrep/semgrepAdd explanatory comments for non-obvious configuration settings, especially when they deviate from defaults or serve ...
Document code purpose
semgrep/semgrepEnsure that code elements have clear documentation explaining their purpose, behavior, and context. This includes fun...
Design consistent tracing interfaces
semgrep/semgrepWhen implementing observability features like tracing, prioritize consistent and extensible API design. Use structure...
CI workflow optimization
semgrep/semgrepOptimize CI/CD workflows by prioritizing reliability over convenience and leveraging built-in platform features. When...
Benchmark performance assumptions
semgrep/semgrepAlways validate performance concerns with actual measurements before making optimization decisions. Avoid making assu...
Add CI safety checks
semgrep/semgrepImplement defensive checks and error handling in CI/CD workflows to prevent failures and ensure robust operations. Th...
Ensure deterministic resume behavior
strands-agents/sdk-pythonWhen implementing persistence and resume functionality in durable execution systems, ensure that state is persisted a...
Extract complex logic helpers
rust-lang/rustComplex or duplicated logic should be extracted into well-named helper functions to improve code readability and main...
Contextual error messages
rust-lang/rustError messages should provide specific context about the error and guide users toward solutions. When reporting synta...
Structure configuration options
dotnet/runtimeDesign and document configuration options (feature flags, environment variables, conditional compilation) to be clear...
Maintain consistent formatting
dotnet/runtimeEnsure consistent formatting and organization throughout the codebase to improve readability and maintainability. Thi...
Decompose complex algorithms
dotnet/runtimeWhen implementing algorithms, break down complex methods that handle multiple concerns into smaller, more focused met...
Choose appropriate error mechanisms
dotnet/runtimeUse the right error handling mechanism for each scenario: exceptions for recoverable situations, assertions only for ...
Support configuration extension patterns
astral-sh/ruffWhen designing configuration systems, provide both replacement and extension options for list-based settings to give ...
Maintain focused module structure
astral-sh/ruffKeep modules focused and well-organized by grouping related functionality together and splitting large files into log...
Leverage existing API utilities
astral-sh/ruffWhen implementing or consuming APIs, always prefer using existing utility methods and abstractions over manual implem...
test real user interactions
TanStack/routerWrite tests that simulate actual user behavior and verify real rendering outcomes rather than testing implementation ...
Maintain backward compatibility
TanStack/routerWhen evolving APIs, always maintain backward compatibility to avoid breaking existing user code. Support both old and...
Ensure documentation clarity
TanStack/routerDocumentation should be clear, accurate, and consistently structured to provide maximum value to developers. Avoid ov...
API backward compatibility
TanStack/routerWhen updating existing APIs, maintain backward compatibility by deprecating old options rather than introducing break...
Robust error handling
RooCodeInc/Roo-CodeImplement comprehensive error handling to prevent crashes and aid debugging. This includes: 1. **Use try/catch block...
Prevent unnecessary processing
RooCodeInc/Roo-CodeOptimize React component performance by minimizing unnecessary operations that can slow down your application: 1. **...
Optimize React components
RooCodeInc/Roo-CodeApply these React optimization techniques to improve component performance and maintainability: 1. **Use stable, uni...
Optimize algorithm implementations
RooCodeInc/Roo-CodeWhen implementing algorithms, ensure they are both efficient and correct across all input cases. Key considerations: ...
Names reflect semantic purpose
RooCodeInc/Roo-CodeIdentifiers (variables, properties, keys, IDs) should accurately reflect their semantic purpose and context. Names sh...
Consistent output path specification
RooCodeInc/Roo-CodeConfiguration files defining operations that generate data outputs must always include a `
Configuration consistency check
RooCodeInc/Roo-CodeEnsure that configuration files and settings are consistent with their intended functionality and maintain portabilit...
Conditional debug logging
RooCodeInc/Roo-CodeRemove or conditionally disable console.log and console.debug statements before committing code to production. These ...
model-appropriate configuration
smallcloudai/refactEnsure AI models use configuration settings that match their specific architecture and requirements. Different model ...
Simplify configuration setup
remix-run/react-routerAvoid redundant configuration parameters and prefer automated solutions over manual maintenance. Remove configuration...
Provide explicit error handling
remix-run/react-routerCreate custom, descriptive errors instead of allowing external dependencies or systems to fail with generic messages....
prefer built-in React types
remix-run/react-routerFavor React's built-in types over custom interfaces when possible, and consolidate to standard library types for bett...
API backward compatibility
remix-run/react-routerWhen evolving APIs, maintain backward compatibility by preserving existing public interfaces while adding new functio...
Optimize hot paths
facebook/reactIn performance-critical code paths that execute frequently, optimize to reduce unnecessary operations that can impact...
proper synchronization practices
facebook/react-nativeEnsure thread safety by using appropriate synchronization mechanisms and understanding thread context. When working w...
preserve component patterns
facebook/react-nativeWhen refactoring React components, maintain essential component patterns including type annotations, ref forwarding c...
organize tests clearly
facebook/react-nativeStructure tests with clear organization, focused scope, and minimal duplication to improve maintainability and debugg...
optimize algorithmic efficiency
facebook/react-nativeWhen implementing algorithms, especially in performance-critical paths like scroll handlers or layout methods, priori...
minimize public API surface
facebook/react-nativeCarefully evaluate whether functionality needs to be exposed as public API. Keep implementations private when they're...
Eliminate unnecessary computations
facebook/react-nativeIdentify and remove redundant operations, unnecessary copies, and repeated computations that add algorithmic overhead...
descriptive specific naming
facebook/react-nativeUse descriptive and specific names that clearly communicate purpose and context. Method names should indicate their p...
dependency management strategy
facebook/react-nativeWhen configuring dependencies in package.json, follow these strategic principles to ensure stable and maintainable pa...
Avoid synchronous main dispatch
facebook/react-nativeAvoid using `RCTUnsafeExecuteOnMainQueueSync` and similar synchronous main queue dispatch methods as they can cause d...
Balance constraints with flexibility
facebook/reactWhen designing APIs, carefully evaluate constraints imposed on consumers. Each limitation should serve a clear purpos...
Understand query method behavior
rails/railsWhen working with database queries in Active Record, it's essential to understand the precise behavior of query metho...
Optimize cache headers
rails/railsUse appropriate HTTP cache headers based on content mutability. For immutable assets (like digest-stamped files), app...
Human-readable configuration values
rails/railsWhen writing configuration files, prioritize human readability and maintainability by using descriptive expressions i...
Efficient data processing
rails/railsWhen implementing algorithms that process large data streams or collections, use a chunking approach rather than proc...
Contextual error messages
rails/railsError messages should provide sufficient context to understand and debug the problem efficiently. Include both the ex...
Content security policy configuration
rails/railsImplement Content Security Policy (CSP) configurations appropriately for your application's context. Use report-only ...
Validate database connections explicitly
quarkusio/quarkusAlways implement explicit database connection validation strategies to ensure robust application behavior during star...
Secure authentication defaults
quarkusio/quarkusConfigure authentication mechanisms with secure default settings to prevent security vulnerabilities. When implementi...
Documentation style consistency
quarkusio/quarkusMaintain consistent documentation style to improve readability and user experience: 1. **Use precise terminology**: ...
Avoid wildcard imports
quarkusio/quarkusWildcard (star) imports like `import java.util.*;` are prohibited in the codebase as they reduce code readability and...
Avoid unnecessary allocations
quarkusio/quarkusMinimize object creation and memory allocations, especially in frequently called methods and hot code paths, to reduc...
Automate style enforcement
quarkusio/quarkusImplement automated code style enforcement using complementary tools rather than relying on manual reviews. Configure...
Optimize memory usage
pytorch/pytorchLimit memory consumption in performance-critical paths by conditionally creating large data structures or deferring a...
Normalize configuration parameters
pytorch/pytorchAlways normalize configuration inputs (especially environment variables) by removing whitespace and applying consiste...
Eliminate redundant operations
pytorch/pytorchAvoid unnecessary operations that can impact performance. This includes: 1. Redundant data transformations: - Loa...
Design for compatibility
pytorch/pytorchWhen evolving APIs, prioritize backward compatibility to minimize disruption for existing users. Add new functionalit...
Choose appropriate exceptions
pytorch/pytorchSelect the proper exception type based on the error scenario to provide clearer error handling and better debugging e...
Write targeted, specific tests
pydantic/pydanticTests should validate specific, well-defined behaviors with clear assertions that directly relate to what's being tes...
Simple defaults, flexible overrides
pydantic/pydanticDesign APIs with intuitive defaults for common use cases while providing specialized options for edge cases. This app...
Semantic over syntactic
pydantic/pydanticChoose names that clearly communicate the purpose and behavior of your code elements, focusing on semantic meaning ra...
Safe attribute access pattern
pydantic/pydanticAlways use safe attribute access patterns to handle potentially null or undefined attributes. Instead of direct attri...
Document configuration relationships
pydantic/pydanticWhen designing configuration options that interact with each other, clearly document these relationships and consider...
Consistent configuration patterns
pydantic/pydanticWhen working with configurations in Pydantic models, maintain consistency by using `ConfigDict()` instead of plain di...
Balance documentation thoroughness
pydantic/pydanticDocumentation should balance completeness with avoiding redundancy. When documenting complex features: 1. Centralize...
Service layer abstraction
prowler-cloud/prowlerSeparate business logic and external service interactions from API views by using dedicated service layers. This impr...
Parameterize security commands
prowler-cloud/prowlerWhen writing security-related CLI commands or remediation steps, always use standardized parameter placeholders (e.g....
Memory usage optimization
prowler-cloud/prowlerOptimize memory usage in high-performance applications by implementing explicit memory management techniques. This in...
Maintain component consistency
prowler-cloud/prowlerUse a consistent approach when working with components to improve code maintainability and ensure visual coherence th...
Ensure migration compatibility
prowler-cloud/prowlerWhen modifying database schemas through migrations, ensure compatibility with existing data. For new required fields,...
Document configuration variables
prowler-cloud/prowlerAlways provide complete documentation for configuration variables, including their exact format, purpose, and behavio...
Document authentication requirements
prowler-cloud/prowlerWhen creating or modifying APIs, always provide comprehensive documentation for authentication methods and prerequisi...
special value handling
prometheus/prometheusAlgorithms must explicitly define and consistently handle special values like NaN, infinity, and edge cases across al...
prevent concurrent data races
prometheus/prometheusAlways analyze shared data access patterns to prevent race conditions in concurrent code. Use appropriate synchroniza...
maintain API consistency
prometheus/prometheusWhen designing or modifying APIs, ensure they follow established patterns and conventions within the codebase rather ...
ensure mathematical correctness
prometheus/prometheusWhen implementing or testing algorithms, ensure mathematical relationships and constraints are maintained throughout ...
Configure dependency management comprehensively
prometheus/prometheusWhen configuring dependency management tools like Renovate, ensure comprehensive setup that includes modern syntax, s...
Complete observability documentation
prometheus/prometheusEnsure documentation for observability systems provides comprehensive information including all required permissions,...
Check nil at usage
prometheus/prometheusPerform null and validity checks at the point where values are actually used, rather than defensively initializing or...
proper async error testing
prisma/prismaWhen testing for expected errors in async code, use Jest's built-in async error testing patterns instead of try-catch...
Ensure concurrent resource cleanup
prisma/prismaAlways ensure proper cleanup of concurrent resources like semaphores, transactions, and async operations, even when e...
validate configuration changes
prettier/prettierConfiguration files require careful validation to ensure they work as intended and don't introduce unintended side ef...
Measure performance impacts
prettier/prettierAlways benchmark and measure actual performance impacts before making optimization decisions, rather than relying on ...
maintain API backward compatibility
prettier/prettierWhen evolving public APIs, prioritize backward compatibility and avoid breaking changes to existing interfaces. Suppo...
Cache correctness validation
prettier/prettierEnsure caching implementations store the correct data and use appropriate strategies for the context. Cache should st...
API documentation clarity
prettier/prettierEnsure API documentation provides clear, accurate, and comprehensive information for developers. This includes precis...
Split complex migrations incrementally
PostHog/posthogBreak complex schema changes into multiple, sequential migrations to ensure deployment safety and proper data handlin...
RESTful endpoint organization
PostHog/posthogAPI endpoints should be properly organized around resources and follow RESTful principles. Avoid placing aggregation ...
optimize ORM queries
PostHog/posthogOptimize Django ORM queries to prevent performance issues and unnecessary database load. Avoid N+1 query problems by ...
Configuration constants management
PostHog/posthogExtract configuration values into well-named constants instead of using magic numbers or inline values. Use consisten...
Check existence before operations
PostHog/posthogAlways verify that keys, IDs, indices, or other required values exist before performing operations that depend on the...
Capture broad exceptions
PostHog/posthogWhen using broad exception handlers like `except Exception:`, always capture and log the exception to avoid silent fa...
API response standardization
PostHog/posthogEnsure API responses follow established patterns and use proper typing. Always use standardized response types like `...
AI context efficiency
PostHog/posthogWhen providing context to LLMs, choose the most efficient method based on the nature and size of the context data. Fo...
Prevent deadlock conditions
pola-rs/polarsCarefully manage resource acquisition and release to prevent deadlocks in concurrent code. Deadlocks typically occur ...
Prevent cryptic errors
pola-rs/polarsAlways implement proper validation and type checking to prevent cryptic error messages. When errors do occur, provide...
Organize tests efficiently
pola-rs/polarsWrite maintainable, well-structured tests that are easy to understand and extend. Tests should remain simple and focu...
Optimize data transformations
pola-rs/polarsWhen implementing data processing operations, avoid unnecessary data transformations, copies, and conversions that ca...
Design for operation flexibility
pola-rs/polarsWhen implementing algorithms that operate on data structures (particularly arrays, lists, or collections), design the...
Defer expensive operations
pola-rs/polarsAvoid triggering expensive computations prematurely in your code. Operations like `collect()`, intensive IO operation...
Choose appropriate abstractions
pola-rs/polarsWhen designing APIs, select data types and patterns that match how they will be consumed while facilitating long-term...
Use appropriate logging levels
python-poetry/poetryUse debug-level logging for technical details and error information that aids developer troubleshooting, while keepin...
Document configuration clearly
python-poetry/poetryConfiguration files, hooks, and settings should include clear, accurate descriptions that explain their purpose and b...
Complete config setting integration
python-poetry/poetryWhen adding new configuration settings, ensure they are properly integrated across all required system components. Co...
Cache expensive computations
python-poetry/poetryIdentify expensive operations that may be called multiple times and implement appropriate caching mechanisms to avoid...
API backwards compatibility
python-poetry/poetryWhen evolving public APIs, prioritize backwards compatibility through proper deprecation strategies and careful inter...
validate algorithmic edge cases
microsoft/playwrightAlgorithms must be thoroughly tested at boundary conditions and edge cases to prevent subtle bugs. Pay special attent...
testing best practices
microsoft/playwrightChoose testing methods, configurations, and approaches that prioritize user experience and reliability over theoretic...
Prioritize documentation clarity
microsoft/playwrightDocumentation should prioritize clarity and actionable guidance over comprehensive coverage. Organize content logical...
explicit undefined checks
microsoft/playwrightAlways use explicit checks for undefined values and return appropriate nullable types instead of relying on implicit ...
Avoid redundant operations
microsoft/playwrightIdentify and eliminate duplicate computations, unnecessary object creation, and redundant function calls to improve p...
Simplify algorithmic implementations
emcie-co/parlantFavor clear, simple algorithmic implementations over complex custom logic. When faced with algorithmic choices, prefe...
Safe null access patterns
emcie-co/parlantAlways use safe access patterns to prevent runtime errors when dealing with potentially null or undefined values. Ins...
safe environment variable access
emcie-co/parlantAlways use `os.environ.get()` with appropriate defaults instead of direct dictionary access to prevent KeyError excep...
Proper span lifecycle
opentofu/opentofuAlways ensure trace spans are properly closed in all code execution paths to prevent trace leaks that can distort obs...
Prevent backing array surprises
opentofu/opentofuWhen modifying slices in Go, be aware that appending to a slice with available capacity will modify the backing array...
Minimize API surface
opentofu/opentofuDesign APIs with minimal exposed surface by encapsulating implementation details within packages. When designing APIs...
Write reliable test cases
open-telemetry/opentelemetry-pythonCreate deterministic and reliable test cases by following these guidelines: 1. Use hardcoded values instead of rando...
Return collections not None
open-telemetry/opentelemetry-pythonReturn empty collections (lists, dicts, sets) instead of None when representing empty states. This reduces null check...
Prevent recursive logging calls
open-telemetry/opentelemetry-pythonAvoid implementing logging calls that could trigger recursive logging patterns, which can lead to infinite loops and ...
Precise configuration specifications
open-telemetry/opentelemetry-pythonEnsure configuration files use tool-specific syntax and conventions while leveraging appropriate defaults. Be intenti...
Place attributes correctly
open-telemetry/opentelemetry-pythonWhen implementing observability with OpenTelemetry, place attributes at the appropriate level in the telemetry hierar...
Pin dependency versions
open-telemetry/opentelemetry-pythonAlways use exact version pinning (==) for dependencies in requirements files rather than version ranges. This ensures...
Choose data structures wisely
open-telemetry/opentelemetry-pythonSelect data structures based on your specific access patterns and performance requirements. Using the right data stru...
Use descriptive names
commaai/openpilotChoose names that clearly communicate purpose and meaning rather than using abbreviations or unclear terms. Names sho...
Tool-specific configuration compatibility
commaai/openpilotWhen working with configuration files that support multiple tools or package managers, ensure that configuration synt...
Prefer asynchronous operations
commaai/openpilotUse asynchronous patterns to prevent blocking operations from degrading system performance, especially in UI contexts...
optimize data structure selection
commaai/openpilotChoose data structures and algorithms based on their computational complexity and access patterns rather than conveni...
Initialize and validate values
commaai/openpilotAlways initialize variables with sensible default values and validate inputs to prevent null reference errors and und...
Be specific with exceptions
commaai/openpilotAvoid catching broad exception types like `Exception` and instead catch specific exceptions that you expect and can h...
prefer built-in error utilities
opengrep/opengrepUse existing error handling utilities and appropriate error mechanisms instead of implementing manual error handling ...
Optimize for common cases
opencv/opencvWhen implementing algorithms, create specialized versions for common cases to improve performance, while maintaining ...
Framework synchronization practices
opencv/opencvWhen implementing concurrent code, always use the framework's provided synchronization primitives rather than direct ...
Document properly with references
opencv/opencvAlways separate code from documentation and use proper referencing techniques. Documentation should be in markdown fi...
Reuse buffers strategically
ollama/ollamaFor frequently called methods or hot code paths, reuse allocations instead of creating new buffers on each call. This...
Platform-aware configuration documentation
ollama/ollamaAlways document platform-specific configuration differences and requirements thoroughly. When writing documentation o...
Loose API coupling
ollama/ollamaMaintain a clear separation between API definitions and their implementations by avoiding direct passing of API struc...
Use async/await pattern
octokit/octokit.netWhen designing or documenting API clients, always use the async/await pattern rather than blocking calls. Replace cod...
Catch specific exceptions
octokit/octokit.netAlways catch specific exception types rather than using general catch blocks. This improves error handling precision,...
robust algorithm implementation
nrwl/nxImplement algorithms that handle edge cases and avoid brittle assumptions about input data or structure formats. Inst...
Ensure configuration consistency
nrwl/nxConfiguration files should maintain consistency in patterns, use correct paths and values, and follow established con...
Documentation metadata consistency
nrwl/nxEnsure documentation uses consistent structural elements and proper metadata to optimize user experience and content ...
Configuration documentation clarity
nrwl/nxConfiguration changes and examples should be documented with clear formatting, proper context, and helpful references...
Vue context boundaries
nuxt/nuxtEnsure Vue composables, reactive state, and side effects are properly scoped within Vue's execution context to preven...
Strategic component loading
nuxt/nuxtChoose component loading strategies based on when interactivity is actually needed, not just code splitting. Lazy pre...
optimize array operations
nuxt/nuxtPre-allocate arrays when the final size is known and consolidate multiple iterations into single loops to reduce memo...
Handle async cancellation properly
nuxt/nuxtWhen implementing async operations with cancellation support, ensure that cancelled operations do not continue to upd...
Cache lifecycle management
nuxt/nuxtImplement comprehensive cache lifecycle management that includes proper key management, invalidation strategies, and ...
Optimize collection operations
novuhq/novuWhen processing collections of data, choose efficient algorithms and data structures that minimize computational comp...
Environment-aware feature gating
novuhq/novuAlways check environment variables, deployment modes, subscription tiers, and feature flags before enabling functiona...
Limit environment variable scope
nodejs/nodeWhen working with environment variables for configuration: 1. **Reuse existing environment variables** rather than c...
Format docs for readability
nodejs/nodeDocumentation should follow consistent formatting and structural patterns to maximize readability and maintainability...
Follow naming conventions
nodejs/nodeMaintain consistent naming conventions across the codebase: - Use PascalCase for class methods (e.g., `All()`, `Get(...
Document non-intuitive code
nodejs/nodeAdd clear comments to explain complex logic, function differences, and non-obvious implementation details. This is es...
Descriptive function names
nodejs/nodeFunction and method names should precisely describe their purpose and behavior. Choose names that explicitly communic...
Await all promises
nodejs/nodeAlways explicitly await all asynchronous operations, especially in cleanup code paths and resource management. Failin...
Verify documentation references
vercel/next.jsWhen writing or updating documentation, ensure all code examples, installation commands, and project references accur...
Proper Use of Suspense in Next.js Components
vercel/next.jsWhen building Next.js applications that leverage server-side rendering (SSR) or Partial Prerendering (PPR), it is ess...
Proper Error Handling in Next.js API Routes
vercel/next.jsThis review focuses on ensuring proper error handling in Next.js API routes. Key principles include validating incomi...
Maintain Consistent Naming Conventions in Next.js Code
vercel/next.jsAs a code reviewer for Next.js projects, ensure that all code artifacts, including component names, file names, and c...
Dynamic API behavior detection
ChatGPTNextWeb/NextChatAPIs should determine behavior based on runtime request characteristics rather than static configuration flags. This ...
Protect network buffer lifecycle
netty/nettyWhen handling network buffers in protocol implementations, ensure proper lifecycle management to prevent memory leaks...
Preserve backward compatibility
netty/nettyWhen evolving APIs in minor versions, always maintain backward compatibility to avoid breaking client code. Follow th...
Optimize search operations
netty/nettyEnhance search algorithm performance by prioritizing common cases, using appropriate data structures, and avoiding un...
Configurable over hardcoded
netty/nettyMake configuration parameters configurable rather than hardcoding values, especially for limits, sizes, and threshold...
Use consistent control structures
nestjs/nestAlways use curly braces for control structures (if, for, while, etc.), even for single-line statements. This improves...
Structure exception handling patterns
nestjs/nestImplement consistent exception handling using framework-provided mechanisms rather than ad-hoc try-catch blocks or ma...
Standardize logger configuration patterns
nestjs/nestMaintain consistent logger configuration and usage patterns across the application while leveraging built-in customiz...
Prevent async race conditions
nestjs/nestDesign async operations to prevent race conditions, memory leaks, and ensure proper resource cleanup. Key principles:...
Pin dependency versions
nestjs/nestExplicitly pin or constrain dependency versions in CI/CD configurations instead of using `latest` tags. This prevents...
Package dependency configuration
nestjs/nestConfigure dependencies appropriately in package.json based on usage patterns and requirements. This improves package ...
HTTP header management
nestjs/nestWhen working with HTTP responses, follow these principles for proper header management: 1. **Only set default header...
Document configuration behaviors
nestjs/nestAlways document configuration options thoroughly, especially for module and service settings. For each configuration ...
Configurable log formatting
nestjs/nestDesign logging systems with customizable formatting and output options. Separate formatting logic into protected meth...
Benchmark before optimizing
nestjs/nestWhen making performance-critical decisions, always validate your approach with benchmarks using realistic data sizes ...
Use descriptive names
neovim/neovimAvoid ambiguous or vague identifiers in favor of specific, self-documenting names that clearly convey purpose and con...
Semantic naming over implementation
neovim/neovimChoose names that reflect the semantic purpose and meaning rather than implementation details or internal mechanisms....
Initialize before dereferencing
neovim/neovimAlways ensure buffers, containers, and data structures are properly initialized before passing them to functions that...
consolidate network APIs
neovim/neovimWhen implementing network functionality, consolidate around standardized APIs like `vim.net.request()` instead of mai...
Configuration variable organization
neovim/neovimUse structured naming patterns and avoid polluting the global namespace when managing configuration variables. Prefer...
Conditional expensive operations
neovim/neovimOnly execute expensive operations when they are actually necessary. Avoid paying performance costs for functionality ...
avoid unnecessary configuration
neovim/neovimAvoid creating special-purpose configuration options when simpler alternatives exist. Don't force users to call setup...
avoid error masking
neovim/neovimDon't use mechanisms that suppress or hide errors unless absolutely necessary for the application flow. Error masking...
Scope JWT authentication tokens
neondatabase/neonAlways include tenant, timeline, and endpoint identifiers in JWT tokens used for service authentication. This ensures...
Proper Option type usage
neondatabase/neonUse Option
Proactive cache warming
neondatabase/neonImplement proactive cache warming strategies to minimize performance degradation after system restarts or during cold...
Pin GitHub action versions
neondatabase/neonAlways pin GitHub Actions to specific commit hashes instead of using major/minor version tags (like @v4). This ensure...
Ensure algorithm robustness
neondatabase/neonWhen implementing algorithms, ensure they handle all edge cases correctly and robustly. Code should gracefully manage...
Connection pooling with pipelining
neondatabase/neonImplement connection pooling with request pipelining for network services to optimize resource usage and improve thro...
Secure credential data handling
n8n-io/n8nAlways protect sensitive credential data through proper encryption, secure storage, and careful handling in code. Key...
Maintain semantic naming consistency
n8n-io/n8nNames should be semantically meaningful and consistent across related concepts in the codebase. This applies to varia...
Explicit environment configuration handling
n8n-io/n8nEnvironment and configuration values should be explicit, visible, and environment-aware. Avoid hardcoded production v...
Descriptive parameter names
n8n-io/n8nUse specific, descriptive parameter names for API resources rather than generic identifiers. Parameter names should c...
Consistent naming patterns
n8n-io/n8nMaintain consistent naming conventions throughout the codebase to improve readability and maintainability. This appli...
Consistent identifier naming
n8n-io/n8nFollow consistent naming conventions for all identifiers to improve code quality, accessibility, and test reliability...
Configuration consistency management
n8n-io/n8nWhen modifying configuration files, ensure all references to the changed values are updated consistently across the e...
Actions configuration best practices
n8n-io/n8nWhen working with GitHub Actions workflows, follow these configuration best practices: 1. **Boolean inputs compariso...
Graph traversal optimization
apache/mxnetWhen working with graph structures, avoid performing redundant depth-first search (DFS) traversals as each traversal ...
Explicit null checks
apache/mxnetAlways use explicit null checks (`value is None` or `value is not None`) rather than implicit truthiness evaluations ...
Comprehensive API documentation
apache/mxnetEnsure all API elements are thoroughly documented following a consistent format. This includes: 1. **All function pa...
Avoid redundant calculations
apache/mxnetEliminate redundant calculations by identifying and caching frequently used values to improve performance. Consider t...
WebSocket lifecycle management
rocicorp/monoEnsure proper WebSocket connection lifecycle management by using `once()` instead of `on()` for cleanup operations an...
verify authorization before operations
rocicorp/monoAlways verify that users have proper authorization to access and modify resources before performing any data operatio...
dependency management practices
rocicorp/monoEnsure comprehensive dependency management in package.json files by following these practices: 1. **Evaluate necessi...
Write user-centric documentation guides
mui/material-uiDocumentation should be written with the user's perspective in mind, using clear, action-oriented language and intuit...
Use slots for composition
mui/material-uiWhen designing React component APIs, implement the slots pattern using `slots` and `slotProps` props instead of speci...
Test behavior not implementation
mui/material-uiFocus tests on user behavior and outcomes rather than implementation details. Structure tests to simulate real user i...
Strict mode-proof hooks
mui/material-uiEnsure your React components work correctly in both development (Strict Mode) and production environments by writing ...
Standardize code formatting patterns
mui/material-uiMaintain consistent code formatting patterns across the codebase to improve readability and maintainability. This inc...
Standardize build configurations
mui/material-uiWhen configuring module builds, maintain consistent and explicit configuration for different module formats (CJS, ESM...
Semantic descriptive naming
mui/material-uiChoose names that clearly communicate purpose, behavior, and semantics of code elements. Names should be self-explana...
Explicit configuration specifications
mui/material-uiWhen writing configuration files, be explicit and precise about dependencies and versions rather than using broad pat...
Event-triggered network requests
mui/material-uiWhen implementing user interactions that trigger network requests, use precise event handling techniques to ensure re...
Document compatibility boundaries
mui/material-uiClearly communicate your API's compatibility guarantees and limitations. When designing APIs, explicitly indicate wha...
Distinguish Next.js routers
mui/material-uiAlways provide separate implementation instructions for Next.js App Router (13+) and Pages Router. These routing syst...
Avoid render cycle allocations
mui/material-uiCreating new objects, arrays, or functions inside a component's render cycle causes unnecessary allocations on every ...
Use accessible terminology
mastodon/mastodonChoose clear, understandable names and terminology that are appropriate for your intended audience, avoiding technica...
prefer early returns
mastodon/mastodonUse early returns and guard clauses to reduce nested conditionals and improve code readability. This pattern makes th...
optimize test organization
mastodon/mastodonOrganize tests to minimize factory creation, reduce duplication, and improve performance by chaining assertions and e...
migration data dependencies
mastodon/mastodonEnsure that migrations properly handle data dependencies and sequencing to prevent deployment failures. When migratio...
Hook responsibility separation
mastodon/mastodonKeep hooks and components focused on single, well-defined responsibilities to maintain clean architecture and avoid m...
explicit API parameters
microsoft/markitdownMake API parameters explicit and named rather than hiding them in **kwargs. This improves clarity, enables better val...
Use proper logging
maplibre/maplibre-nativeAlways use the project's standard logging system (mbgl::Log) with appropriate log levels instead of ad-hoc solutions ...
Structured coroutine management
maplibre/maplibre-nativeAlways bind coroutine scopes to appropriate lifecycles and follow consistent patterns for asynchronous operations. Pr...
Preallocate collection capacity
maplibre/maplibre-nativeWhen the final size of a collection is known before adding elements, use `reserve()` to preallocate memory capacity. ...
Extract workflow scripts
maplibre/maplibre-nativeMove complex scripts out of workflow YAML files into separate, dedicated script files in your repository. This practi...
Enforce clear data ownership
maplibre/maplibre-nativeAlways establish and maintain clear ownership semantics in concurrent code to prevent data races. This includes: 1. ...
Document platform requirements
maplibre/maplibre-nativeWhen setting or changing minimum platform version requirements, always document the specific technical reasons for th...
Descriptive named constants
maplibre/maplibre-nativeReplace magic numbers and unclear variables with descriptive named constants using appropriate naming conventions. Th...
Configure platform-specific builds
maplibre/maplibre-nativeEnsure build and distribution configurations are properly documented and optimized for each target platform. For cros...
Separate user system data
logseq/logseqSeparate user-facing data from system/implementation data using proper namespacing and schema design to prevent data ...
Fail fast explicitly
logseq/logseqWhen critical components or operations fail, throw explicit errors rather than silently continuing or returning nil. ...
Use reactive hooks
lobehub/lobe-chatAlways use React's reactive hook patterns instead of imperative state access or manual effect management. This ensure...
Use idempotent migrations
lobehub/lobe-chatAlways use defensive programming patterns in migration scripts to ensure they can be executed multiple times without ...
Provider-based interface design
lobehub/lobe-chatWhen designing interfaces that handle multiple providers or services, organize the API structure around provider-spec...
Explicit environment declarations
lobehub/lobe-chatAlways explicitly declare environment variables in configuration files, even when they have default values. Use consi...
CSS utility usage
lobehub/lobe-chatUse CSS utility functions and avoid complex inline calculations for better maintainability and readability. Prefer `c...
Maintain comprehensive error handling
LMCache/LMCacheAlways preserve and implement thorough error handling that includes proper resource cleanup, meaningful logging, and ...
Configuration validation standards
LMCache/LMCacheEnsure configuration parameters follow consistent validation, naming, and default value standards to improve code saf...
optimize computational complexity
llvm/llvm-projectWhen implementing algorithms, be mindful of computational complexity and optimize for efficiency by avoiding expensiv...
Configuration completeness validation
llvm/llvm-projectEnsure configuration options are complete and properly validated before use. When implementing configuration parsing ...
validate bounds before access
ggml-org/llama.cppAlways validate array indices, buffer sizes, and container bounds before accessing elements to prevent out-of-bounds ...
prioritize compile-time optimizations
ggml-org/llama.cppIn performance-critical code, favor compile-time optimizations over runtime flexibility to enable better compiler opt...
maintain code consistency
ggml-org/llama.cppAlways follow the existing code style patterns and conventions found in the surrounding codebase rather than introduc...
API minimalism principle
ggml-org/llama.cppKeep APIs minimal by avoiding redundant interfaces and preferring simple solutions over complex ones. When adding fun...
Safe operations with fallbacks
BerriAI/litellmImplement defensive programming by wrapping potentially failing operations in safe methods that provide fallback beha...
Prevent flaky test timing
langfuse/langfuseReplace non-deterministic timing patterns with reliable alternatives to prevent flaky tests. This includes: 1. Use e...
Pin dependency versions
langfuse/langfuseAlways pin external dependencies to specific versions in CI/CD workflows to ensure build reproducibility, stability, ...
Explicit null value checks
langfuse/langfuseUse explicit null/undefined checks instead of truthy/falsy checks when handling potentially null or undefined values....
Configuration value consistency
langfuse/langfuseMaintain consistency in configuration values across the application by following these practices: 1. **Use properly ...
Prevent code injection vulnerabilities
langflow-ai/langflowWhen evaluating user-provided code or handling dynamic content, implement strict security measures to prevent malicio...
Database configuration clarity
langflow-ai/langflowWhen documenting database configuration or setup procedures, provide specific, actionable instructions with clear ver...
Avoid hardcoded configuration values
langflow-ai/langflowReplace hardcoded configuration values with configurable parameters to improve flexibility and maintainability. Hardc...
AI response variability
langflow-ai/langflowWhen documenting AI model interactions, account for the non-deterministic nature of AI responses and avoid assumption...
AI model chunk sizing
langflow-ai/langflowWhen configuring text processing components that work with AI embedding models, proactively consider tokenization lim...
Use database-native types
langchain-ai/langchainjsAlways leverage database-native data types and appropriate schema design to maximize performance and query capabiliti...
Eliminate redundant code
langchain-ai/langchainjsSimplify code by eliminating redundancy and unnecessary complexity. This improves readability, reduces potential bugs...
Dependency classification standards
langchain-ai/langchainjsProperly classify dependencies in package.json according to their usage pattern and project guidelines. This ensures ...
Comprehensive AI documentation
langchain-ai/langchainjsWhen documenting AI integrations, provide comprehensive examples that showcase all common initialization and usage pa...
Avoid hardcoded configurations
langchain-ai/langchainjsAlways parameterize values that might vary across different environments or users instead of hardcoding them in your ...
Wrap errors meaningfully
kubernetes/kubernetesAlways wrap errors with meaningful context that explains what operation failed and why. Use proper error wrapping wit...
Prevent information disclosure
kubernetes/kubernetesAvoid exposing sensitive information through error messages, logs, configuration, or other output channels that might...
Feature gate configuration management
kubernetes/kubernetesEnsure feature gates are properly managed across all configuration files and contexts. Feature-specific permissions, ...
Standardize network tools
kubeflow/kubeflowWhen performing network operations in build scripts or containers, prefer `curl` over `wget` for HTTP requests to sta...
Prioritize readability over brevity
kubeflow/kubeflowWhen writing code, favor readability and maintainability over clever or compact solutions. Break down complex logic i...
Pin version dependencies
kubeflow/kubeflowExplicitly pin version dependencies in configuration files to ensure reproducible builds and prevent breaking changes...
Load configurations efficiently
kubeflow/kubeflowWhen designing components that require configuration, follow these practices to enhance performance, maintainability,...
Follow API conventions
kubeflow/kubeflowWhen designing APIs, adhere to established API conventions, particularly Kubernetes API conventions when working with...
Externalize configuration parameters
kubeflow/kubeflowCreate configurations that can be easily managed outside your application code. Design configuration parameters to be...
Document code thoroughly
kubeflow/kubeflowAlways include appropriate documentation in your code to improve readability, maintainability, and usability: 1. **D...
Contextualize and classify errors
kubeflow/kubeflowAlways provide meaningful context when handling errors, and classify them appropriately based on their source. This i...
Centralize configuration constants
kubeflow/kubeflowStore configuration constants, defaults, and environment variable mappings in dedicated configuration files rather th...
Use defensive null checks
JetBrains/kotlinWhen working with properties or methods that could potentially be null, use Kotlin's null safety features defensively...
minimize merge conflicts
kilo-org/kilocodeWhen working with upstream codebases, prioritize coding approaches that minimize merge conflicts while maintaining fu...
validate configuration dependencies
apache/kafkaValidate configuration dependencies and constraints at initialization time rather than allowing invalid combinations ...
optimize data structures
apache/kafkaWhen working with data structures and collections, optimize for performance and correctness by using modern APIs, pro...
Optimize collection conversions
apache/kafkaWhen converting between Java and Scala collections or performing set operations, choose methods that minimize tempora...
Improve code readability
apache/kafkaWrite code that prioritizes readability through clear string formatting, descriptive method calls, and well-organized...
Ensure complete JavaDoc coverage
apache/kafkaAll public classes, methods, and parameters must have comprehensive JavaDoc documentation. This includes: 1. **Class...
catch specific exceptions
apache/kafkaAvoid catching overly broad exception types like `Throwable` or `Exception` when you can be more specific about the e...
preserve error context
jj-vcs/jjWhen handling errors, preserve the original error context and avoid exposing internal representations to users. Use `...
Minimize API scope
jj-vcs/jjWhen designing APIs, prioritize simplicity and focused scope over feature completeness. Before adding new API methods...
Use configuration constants
menloresearch/janAlways use named constants, enums, or well-defined configuration objects instead of magic strings, numbers, or inline...
model description accuracy
menloresearch/janEnsure AI model descriptions are specific, capability-focused, and avoid marketing language or temporal references li...
Implement graceful error fallbacks
menloresearch/janAlways implement fallback mechanisms when primary operations can fail, especially for critical operations like resour...
Document AI infrastructure requirements
menloresearch/janWhen documenting AI applications that run local models or perform inference, always provide comprehensive infrastruct...
Cross-platform configuration simplification
menloresearch/janWhen writing configuration files and scripts, prioritize cross-platform compatibility while keeping configurations si...
AI model configuration completeness
menloresearch/janEnsure all necessary AI model parameters are properly configured and passed through the system. AI models require com...
AI accuracy documentation
menloresearch/janEnsure accurate representation of AI model capabilities, proper attribution, and honest claims about functionality. W...
telemetry consistency standards
istio/istioEnsure telemetry attribute population logic is consistent across all components and follows established standards. Wh...
Document observability rationale
istio/istioWhen introducing, modifying, or removing observability features (tracing, metrics, monitoring configurations), always...
API version compatibility first
istio/istioWhen selecting API versions, prioritize compatibility over using the latest available version. Choose older, stable A...
prefer idiomatic patterns
vadimdemedes/inkChoose language-native methods and control structures that make code more readable and maintainable. Use built-in fun...
Package.json configuration standards
vadimdemedes/inkEnsure package.json follows modern standards and maintains consistency across configuration fields. Use structured ex...
avoid `any` type usage
vadimdemedes/inkReplace `any` type annotations with more specific types to improve type safety and null handling. The `any` type disa...
Use structured logging fields
influxdata/influxdbAlways use structured logging with descriptive field names rather than string interpolation. Include relevant context...
Prevent nil dereferences
influxdata/influxdbAlways verify that pointers, slices, or arrays are non-nil and have sufficient elements before attempting to access t...
Prefer configurable values
influxdata/influxdbAlways use configurable values instead of hardcoded defaults when available. This ensures that user preferences are r...
Performance-conscious metrics implementation
influxdata/influxdbImplement metrics collection that is both comprehensive and minimally impactful on system performance. Design your me...
Include explanatory examples
influxdata/influxdbAlways enhance documentation with concrete, illustrative examples that demonstrate expected inputs, formats, or outpu...
Avoid unnecessary work
influxdata/influxdbWhen optimizing performance-critical code paths, eliminate redundant operations and unnecessary processing: 1. **Exi...
Avoid flaky test patterns
influxdata/influxdbWrite reliable tests by avoiding common patterns that can lead to flaky behavior. Specifically: 1. Avoid arbitrary t...
Test all code paths
elie222/inbox-zeroWrite comprehensive tests that cover all code paths including edge cases, error conditions, and different parameter c...
Prevent workflow recursion
elie222/inbox-zeroControl GitHub Actions workflow execution to avoid infinite loops and unnecessary builds. Implement these practices: ...
Normalize API responses
elie222/inbox-zeroDesign APIs to return consistent response structures across different data sources or providers. Normalize responses ...
Handle AI operation failures
elie222/inbox-zeroAlways implement proper error handling for AI service operations. AI services can fail due to rate limiting, network ...
Ensure API contract integrity
elie222/inbox-zeroMaintain strict consistency between API implementation and contract by ensuring: 1. Request/response schemas match ex...
Define schema relations correctly
elie222/inbox-zeroWhen designing database schemas, ensure relations and constraints are explicitly and correctly defined: 1. Every mod...
Complete hook dependency arrays
elie222/inbox-zeroEnsure all hooks (useEffect, useCallback, useMemo) explicitly list every dependency used within their callback functi...
Cache invariant computations
elie222/inbox-zeroAvoid repeatedly computing values that don't change frequently. For data structures, maps, or validation schemas used...
Semantic variable naming
hyprwm/HyprlandVariable names should clearly convey their purpose, type, and units to improve code readability and prevent errors. F...
prefer std::error_code parameters
hyprwm/HyprlandWhen using std::filesystem operations, prefer passing std::error_code parameters instead of relying on try-catch bloc...
prefer managed pointers
hyprwm/HyprlandRaw pointers are banned in new code unless absolutely necessary. Instead, use managed pointer types to prevent null p...
Precise documentation language
hyprwm/HyprlandDocumentation language should be precise, unambiguous, and clearly scoped to prevent misinterpretation while maintain...
Precise configuration patterns
hyprwm/HyprlandUse precise file patterns and correct installation paths in CMake configuration to avoid unintended inclusions and en...
use Option combinators
juspay/hyperswitchLeverage Rust's Option API methods like `map`, `and_then`, `is_some()`, and `filter` instead of manual pattern matchi...
Database schema consistency
juspay/hyperswitchEnsure database schema definitions are consistent with ORM annotations and include proper constraints for data integr...
Choose optimal algorithms
juspay/hyperswitchWhen implementing functionality, carefully evaluate and select the most efficient algorithmic approaches for data pro...
Standardize build configuration patterns
helix-editor/helixExplicitly define and standardize build configuration patterns across the project to ensure consistent behavior and o...
hide implementation details
helix-editor/helixWhen designing APIs, avoid exposing internal structures, implementation details, or platform-specific concepts to ext...
consistent naming conventions
helix-editor/helixMaintain consistent naming patterns throughout your codebase, following established conventions and ensuring uniformi...
avoid quadratic complexity
helix-editor/helixWhen working with data structures, especially ropes and collections, avoid algorithms that result in quadratic time c...
avoid panics gracefully
helix-editor/helixReplace panics, expects, and unwraps with graceful error handling that provides user feedback and allows the system t...
avoid hardcoded configuration values
helix-editor/helixAvoid hardcoding configuration values that affect user experience or behavior. Instead, make these values configurabl...
Safe property access patterns
grafana/grafanaUse appropriate null/undefined handling techniques based on the context to prevent runtime errors. Be mindful of the ...
Prefer null-safe access
grafana/grafanaAlways use null-safe access patterns when dealing with potentially undefined values to prevent runtime errors and imp...
Optimize performance patterns
grafana/grafanaChoose efficient implementation patterns that improve performance. Apply these optimizations throughout your code: 1...
Name for purpose first
grafana/grafanaChoose names that lead with their primary purpose or category, followed by specific details. This makes code more dis...
Minimize database joins
grafana/grafanaPrefer direct filtering or specialized service methods over complex JOIN operations, especially when maintaining or r...
Maintain configuration documentation accuracy
grafana/grafanaAlways ensure configuration documentation accurately reflects the current system capabilities, limitations, and featu...
Judicious configuration management
grafana/grafanaCarefully manage configuration options, including feature flags, to balance flexibility with maintainability: 1. **U...
Fail-safe security defaults
grafana/grafanaAlways implement security features with fail-safe defaults that deny access or disable insecure functionality unless ...
Consistent semantic naming
grafana/grafanaUse consistent, specific, and semantically appropriate naming conventions throughout the codebase. When creating new ...
Consistent API versioning approach
grafana/grafanaAdopt and document a consistent approach to API versioning across your services. The chosen format should be clearly ...
Component architecture principles
grafana/grafanaExtract logic that doesn't render JSX into custom hooks instead of components. Components that don't return markup cr...
User-focused documentation structure
block/gooseDocumentation should prioritize user needs and problems over technical implementation details. Start with the "why" -...
Optimize memory and algorithms
block/gooseFocus on efficient memory usage and algorithm selection while preserving functionality. Apply these optimization tech...
Handle errors intentionally
block/gooseAvoid generic catch-all error handling that masks important failures. Instead, be selective about which errors to han...
consolidate API parameters
block/goosePrefer consolidating common configuration and parameters in API constructors or base methods rather than requiring mu...
avoid concurrency anti-patterns
block/gooseAvoid common concurrency anti-patterns that lead to race conditions, deadlocks, and unreliable behavior. Use structur...
AI terminology consistency
block/gooseMaintain consistent terminology when describing AI systems, capabilities, and workflows throughout documentation and ...
Descriptive idiomatic identifiers
gin-gonic/ginUse descriptive names for variables, types, and interfaces that follow Go language idioms. Avoid single-letter variab...
Consistent error patterns
gin-gonic/ginImplement consistent error handling patterns throughout your codebase to improve readability and maintainability. **...
Structure user documentation
ghostty-org/ghosttyWhen documenting complex features or configuration options, structure your documentation with these four key elements...
Semantic name clarity
ghostty-org/ghosttyNames should clearly and accurately reflect the purpose of variables, methods, and other identifiers. Follow these pr...
Prevent unnecessary memory operations
ghostty-org/ghosttyAvoid redundant memory allocations and copies when simpler alternatives exist. This includes: 1. Use in-place compar...
Optimize comparison patterns efficiently
ghostty-org/ghosttyChoose efficient comparison patterns and algorithms based on the data type and use case. Key guidelines: 1. For stri...
In-tree build configurations
ghostty-org/ghosttyKeep all build configuration files (Snapcraft, Flatpak manifests, etc.) in the repository alongside your code to ensu...
prefer settings over environment
google-gemini/gemini-cliPrefer settings.json over environment variables and CLI flags for user configuration options. Environment variables s...
Centralize proxy configuration
google-gemini/gemini-cliAvoid duplicate proxy configuration across your application by establishing a single point of proxy setup and leverag...
Centralize configuration management
google-gemini/gemini-cliPrefer centralized configuration files (settings.json, settings.ts) over environment variables for application settin...
Validate with sensible defaults
fatedier/frpImplement a comprehensive configuration validation strategy that combines centralized validation functions with appro...
Follow Go naming conventions
fatedier/frpAdhere to Go's standard naming conventions for identifiers: 1. **Control visibility with capitalization**: - Use ...
Optimize migration code
laravel/frameworkWhen writing database migration code, prioritize clarity and efficiency to ensure migrations are reliable and maintai...
Optimize loop operations
laravel/frameworkWhen writing loops, optimize for both readability and performance by following these key principles: 1. **Exit early...
Disable coverage in workflows
laravel/frameworkKeep code coverage tools disabled in CI/CD workflows unless they're specifically needed for generating coverage repor...
Descriptive configuration keys
laravel/frameworkConfiguration keys should clearly indicate their value type, units, or expected format to prevent misunderstandings a...
Test observable behavior
flutter/flutterFocus on testing what users see and experience rather than internal implementation details. Tests should verify the a...
Make errors explicit
flutter/flutterAlways make error conditions explicit and visible rather than hiding them through silent failures, default return val...
Future-proof configuration defaults
flutter/flutterWhen designing configuration options, avoid hardcoded values and ensure defaults can be changed in future versions wi...
Validate configuration defaults
gofiber/fiberConfiguration structs should validate input values and provide sensible defaults that work well in production environ...
Use context for configuration
gofiber/fiberWhen accessing application state or configuration within request handlers, always use the context method `c.App().Sta...
Include practical examples
gofiber/fiberDocumentation should include practical, working examples that demonstrate real-world usage scenarios. When introducin...
Document mutex usage
gofiber/fiberAlways document mutex fields and their purpose, ensure proper locking/unlocking patterns, and avoid redundant locks w...
Proper Handling of Promises in Fastify Implementations
fastify/fastifyWhen implementing Fastify applications in TypeScript, it is important to follow consistent patterns for handling prom...
Content negotiation design
fastify/fastifyWhen building APIs, implement proper content negotiation to handle various media types in both requests and responses...
Consistent descriptive naming
fastify/fastifyUse precise, consistent, and descriptive naming conventions throughout your code to enhance readability and maintaina...
Benchmark before choosing methods
fastify/fastifyAlways benchmark different implementation approaches for performance-critical operations before selecting a method. D...
Use pytest fixtures effectively
fastapi/fastapiTests should use pytest fixtures to improve organization, promote test isolation, and avoid code duplication. Fixture...
Use early returns
fastapi/fastapiDecrease indentation levels in your code by using early returns for edge cases and guard conditions. This approach im...
Respect async execution order
fastapi/fastapiWhen working with asynchronous code, always be mindful of the execution order of operations, particularly with regard...
Proper HTTP status codes
fastapi/fastapiWhen implementing authentication and authorization systems, use semantically correct HTTP status codes to accurately ...
Optimize hot paths
expressjs/expressWhen writing code that will be executed frequently (hot paths), prioritize performance optimizations that reduce over...
Optimize dependency automation
expressjs/expressConfigure automated dependency update tools (like Dependabot) to balance security needs against developer cognitive l...
Access settings properly
expressjs/expressAlways use the provided settings accessor methods (`app.get()`, `app.set()`, `app.enabled()`, `app.disabled()`) to ac...
Algorithm selection correctness
evanw/esbuildChoose algorithms that correctly match the problem requirements and understand their computational properties and sid...
mark experimental configuration features
electron/electronAlways mark experimental and deprecated configuration options with appropriate stability indicators in documentation....
Ensure async error cleanup
electron/electronAlways ensure cleanup code executes and avoid creating dangling promises in error handling scenarios. Use try-catch-f...
consistent nullable returns
electron/electronEstablish consistent patterns for nullable return values in APIs and document them clearly. Use `null` consistently f...
Avoid exposing sensitive APIs
electron/electronDo not enable configurations that expose Node.js or Electron APIs to untrusted web content in renderer processes. Thi...
Parallel branch traceability
elastic/elasticsearchWhen implementing algorithms with parallel processing branches, ensure proper traceability and data consistency acros...
Exceptions for critical errors
elastic/elasticsearchUse exceptions rather than assertions for handling critical error conditions that need to be caught in production. As...
Defensive null handling
elastic/elasticsearchAlways handle null references and values defensively to prevent NullPointerExceptions and unexpected behavior. Follow...
Configure type serialization
elastic/elasticsearchWhen working with databases that exchange data with other systems, ensure proper serialization and deserialization of...
Clarity over uncertainty
elastic/elasticsearchTechnical documentation should use precise language that clearly differentiates between product behavior and user con...
preserve serialization compatibility
duckdb/duckdbWhen making changes to serialized data structures, always preserve backward and forward compatibility to prevent brea...
prefer settings over pragmas
duckdb/duckdbWhen implementing configuration options, prefer database settings over pragma functions to maintain consistency and b...
optimize hot path performance
duckdb/duckdbAvoid expensive operations in frequently executed code paths by implementing performance optimizations such as lookup...
maintain API backward compatibility
duckdb/duckdbWhen evolving APIs, prioritize backward compatibility by creating new methods or overloads rather than modifying exis...
Constructor configuration injection
duckdb/duckdbPrefer injecting configuration objects through constructors rather than passing them as ad-hoc parameters or using gl...
comprehensive database testing
duckdb/duckdbDatabase tests should execute actual queries and verify results comprehensively, not just check query plans or use ha...
Use standardized logging pattern
stanfordnlp/dspyAlways use the standardized logging pattern with module-level loggers instead of print statements or direct logging c...
Optional dependency management
stanfordnlp/dspyAvoid including optional or provider-specific dependencies in the main dependency list. Dependencies should only be r...
Configuration context consistency
drizzle-team/drizzle-ormEnsure configuration names, values, and settings accurately reflect their intended context and usage. Configuration m...
Prevent N+1 queries
django/djangoThe N+1 query problem is one of the most common performance bottlenecks in Django applications. This occurs when you ...
Optimize computational complexity
django/djangoIdentify and reduce computational complexity in your code by minimizing redundant operations and simplifying algorith...
Measure before optimizing
django/djangoAlways measure performance impact before implementing optimizations and focus on changes with meaningful benefits. Py...
Defend against nulls
django/djangoAlways use defensive programming techniques when handling potentially null or empty values to avoid runtime errors. C...
Use dynamic configuration access
discourse/discourseAlways access configuration values through proper service APIs rather than hardcoding them or using unreliable access...
Safe setting modifications
discourse/discourseWhen modifying site settings during operations like imports, jobs, or plugin initialization, implement proper safegua...
Include contextual log information
discourse/discourseLog messages should include sufficient context to make them useful for debugging, monitoring, and audit trails. Inclu...
Consistent null safety patterns
discourse/discourseApply null safety operators consistently throughout your code to prevent runtime errors and improve readability. Use ...
Avoid N+1 queries
discourse/discoursePrevent N+1 query performance issues by batching database operations instead of making individual queries within loop...
API parameter handling
discourse/discourseEnsure consistent and safe handling of parameters and data across API endpoints. This includes using proper serializa...
API parameter clarity
discourse/discourseDesign API parameters with clear naming, structured formats, and intuitive interfaces that are easy for clients to us...
Validate access controls
langgenius/difyAlways implement comprehensive validation for access control mechanisms to prevent unauthorized access and privilege ...
Name by semantic purpose
langgenius/difyChoose names that reflect the semantic purpose and meaning rather than implementation details or arbitrary values. Us...
Validate operation permissions
denoland/denoEnsure appropriate permission checks are implemented before performing security-sensitive operations that access file...
Use appropriate error types
denoland/denoFunctions should use specific, appropriate error handling mechanisms rather than generic or brittle approaches. This ...
prefer safe optional returns
denoland/denoWhen designing APIs and handling potentially missing or unavailable values, prefer returning optional types (Option
explicit dependency configuration
denoland/denoEnsure dependency configurations are explicit and predictable to avoid confusion and unexpected build behavior. Avoid...
defensive null handling
denoland/denoUse defensive programming patterns to prevent null-related issues before they occur. This includes creating safe obje...
Use modern API methods
deeplearning4j/deeplearning4jWhen implementing algorithms with numerical libraries like ND4J, always prefer the most direct and type-safe API meth...
Minimize object allocations
deeplearning4j/deeplearning4jAvoid creating unnecessary temporary objects or arrays which can impact performance through increased garbage collect...
Keep configurations current
deeplearning4j/deeplearning4jEnsure all configuration elements (dependencies, build settings, preprocessor flags) are up-to-date, documented, and ...
Fail fast clearly
deeplearning4j/deeplearning4jDetect and report errors as early as possible with detailed context to prevent silent failures and aid debugging. Val...
Document AI APIs completely
deeplearning4j/deeplearning4jWhen developing AI libraries and tools, provide comprehensive and accurate API documentation that helps users navigat...
Cross-platform algorithm optimization
deeplearning4j/deeplearning4jWhen implementing algorithms that need to execute efficiently across different platforms, consider both compile-time ...
Configurable resource locations
deeplearning4j/deeplearning4jAlways make file paths, temporary directories, and resource locations configurable with reasonable defaults instead o...
Compare floating-point safely
deeplearning4j/deeplearning4jWhen implementing numerical algorithms, never compare floating-point values directly for equality due to precision er...
Use precise networking terminology
cypress-io/cypressWhen writing error messages or documentation related to network requests and cross-origin policies, use precise termi...
prefer existence over truthiness
cypress-io/cypressUse explicit existence checks instead of truthiness checks when dealing with object properties, null/undefined values...
meaningful test assertions
cypress-io/cypressWrite tests that verify specific behavior and outcomes rather than relying on weak assertions like snapshots or gener...
GraphQL mutation design
cypress-io/cypressDesign GraphQL mutations to return meaningful objects rather than simple booleans, and use simple ID parameters inste...
Environment variable handling
cypress-io/cypressEnvironment variables should be properly validated, parsed, and documented with clear override mechanisms. Always val...
Choose appropriate log levels
cypress-io/cypressSelect log levels based on the intended audience and actionability of the message. Use `debug` for internal developme...
Default None not empty
crewaiinc/crewaiAlways use `None` as the default value for optional parameters and class attributes instead of empty collections (`[]...
Pause tracking during side-effects
vuejs/coreWhen executing side-effects in reactive systems (like event handlers, cleanup functions, or async operations), always...
Optimize common search paths
vuejs/coreImplement dedicated fast paths for common search patterns while maintaining a complete fallback path for edge cases. ...
log complete error objects
adonisjs/coreAlways log complete error objects rather than just error messages to preserve stack traces, error codes, and debuggin...
Guarantee cleanup execution
vuejs/coreWhen implementing features that require cleanup or state restoration, always use try-finally blocks to ensure cleanup...
Consistent documentation language
home-assistant/coreMaintain consistency in wording, formatting, and specificity across all documentation strings to improve readability ...
Batch operations efficiently
home-assistant/coreCollect and execute similar operations together rather than performing them individually to reduce overhead and impro...
API documentation consistency
home-assistant/coreEnsure all API-related descriptions, field names, and documentation accurately reflect the terminology and specificat...
Working configuration examples
continuedev/continueConfiguration examples should be complete, accurate, and ready to use without modification. This applies to both code...
Safe property access
continuedev/continueAlways use proper null safety patterns when accessing properties that might be null or undefined. This prevents runti...
Prevent broken interactions
continuedev/continueEnsure UI elements' visual state (e.g., disabled, active) always matches their actual behavior. When an element appea...
Prevent async deadlocks
continuedev/continueAvoid circular dependencies in asynchronous code paths that can lead to deadlocks or indefinite blocking. When using ...
Maintain API compatibility
continuedev/continueWhen modifying existing APIs, ensure backward compatibility to prevent runtime failures and minimize migration effort...
Write deterministic test assertions
docker/composeTests should be deterministic and explicit in their assertions to ensure reliability and maintainability. Follow thes...
Wrap and check errors
docker/composeAlways wrap errors with meaningful context and use typed error checking instead of string matching. This helps with e...
Use standard API fields
docker/composeWhen designing APIs or interfaces, prioritize using existing standard fields and patterns from established APIs rathe...
Use API options pattern
docker/composeDesign API methods using options objects instead of multiple parameters. This pattern provides better extensibility, ...
Prevent unintended CI behaviors
docker/composeEnsure CI/CD pipelines maintain predictable and reliable behavior by avoiding changes that introduce unexpected side ...
Prevent sensitive data exposure
docker/composeImplement comprehensive checks to prevent accidental exposure of sensitive data through multiple vectors in configura...
Keep code structure flat
docker/composeMaintain code readability by minimizing nesting depth and using appropriate control structures. Prefer flat code orga...
consistent formatting choices
docker/composeMaintain consistent formatting and style choices throughout your codebase to improve readability and maintainability....
Configuration documentation clarity
docker/composeEnsure configuration documentation clearly and accurately describes environment variables, command-line flags, and th...
use logging over print
comfyanonymous/ComfyUIReplace all `print()` statements with appropriate logging calls using Python's built-in logging module. This applies ...
optimize computational efficiency
comfyanonymous/ComfyUIImplement memoization and guard clauses to eliminate redundant computations and improve algorithmic performance. Many...
explicit null handling strategies
comfyanonymous/ComfyUIFunctions and APIs should employ explicit strategies for handling null/None values rather than leaving null handling ...
Document complex code
comfyanonymous/ComfyUIAdd explanatory comments or docstrings for complex, specialized, or non-obvious code that may not be immediately clea...
Semantic naming patterns
openai/codexUse names that clearly convey purpose and maintain consistency across related components. Avoid generic identifiers (...
Prefer specific identifiers
openai/codexAlways use specific, descriptive names for identifiers rather than generic terms. Names should clearly indicate their...
Organize code top down
openai/codexStructure code files with a clear top-down organization, placing primary functions and important declarations at the ...
Minimize blocking operations
openai/codexWhen writing concurrent code, minimize blocking operations to maintain responsiveness and prevent performance bottlen...
Leverage style tools
openai/codexMaintain consistent code style by using and respecting the project's established formatting tools and patterns. Run l...
Avoid hard-coded configuration
openai/codexMake scripts and applications flexible by avoiding hard-coded configuration values. Instead, allow users to provide c...
Strategic telemetry implementation
cline/clineImplement telemetry collection strategically to ensure system reliability and meaningful data capture. Place telemetr...
Avoid generic suffixes
cline/clineAvoid using generic suffixes like "Response", "Result", or "Request" in type names, especially for non-request types....
Setting declaration practices
ClickHouse/ClickHouseAlways declare settings before using them and optimize access patterns for performance. Settings must be properly dec...
Documentation precision standards
ClickHouse/ClickHouseEnsure API documentation uses precise type specifications, proper formatting, and clear language to improve developer...
Write actionable documentation
snyk/cliDocumentation should be written in active voice with concrete examples and clear context. Avoid passive constructions...
Use centralized configuration access
snyk/cliAlways access configuration values through the configuration object rather than direct helper functions or environmen...
Optimize variable declarations
snyk/cliDeclare variables close to their usage point and choose appropriate types to improve code readability and reduce cogn...
debug logging reliability
snyk/cliEnsure debug logging behaves correctly by only activating when debug flags are explicitly enabled, while providing co...
avoid hardcoded configuration values
snyk/cliReplace hardcoded URLs, ports, file paths, and environment-specific strings with configurable parameters. Hardcoded v...
Use strict test doubles
chef/chefAlways use strict test doubles (instance_double, class_double) instead of basic doubles or OpenStruct in tests. Stric...
Standardize installation directory paths
chef/chefMaintain consistent and separate installation paths for different build types to prevent conflicts and improve system...
Secure network operations
chef/chefWhen performing network operations, prioritize security and configurability to ensure robustness across different env...
Document configuration decisions
chef/chefAdd clear comments explaining the rationale behind configuration decisions, especially for workarounds, compatibility...
Document configuration completely
chef/chefAlways provide complete documentation for configuration options, including defaults, override methods, and security i...
Use pytest best practices
bridgecrewio/checkovAdopt modern pytest features to create maintainable, isolated, and comprehensive tests. This includes: 1. **Prefer p...
Preserve API compatibility
bridgecrewio/checkovWhen modifying existing APIs, function signatures, or return structures, always maintain backward compatibility to pr...
Precise configuration validation
bridgecrewio/checkovEnsure configuration validation logic accurately reflects security intentions and best practices. When writing valida...
Provide error feedback
calcom/cal.comAlways provide clear user feedback when errors occur or operations fail, rather than allowing silent failures or show...
Prefer early returns
calcom/cal.comUse early returns and guard clauses instead of nested if-else statements to improve code readability and reduce compl...
optimize iteration patterns
calcom/cal.comMinimize computational complexity by optimizing iteration patterns and data processing flows. Apply early filtering w...
Configuration access patterns
calcom/cal.comEnsure configuration data is accessed through proper service layers with dependency injection rather than direct data...
Avoid redundant operations
calcom/cal.comIdentify and eliminate duplicate or inefficient operations that waste computational resources. Common patterns to wat...
Avoid generic naming
calcom/cal.comChoose specific, descriptive names over generic ones for all identifiers including variables, functions, components, ...
Use consistent test patterns
oven-sh/bunStandardize testing by leveraging established patterns and helper functions throughout your test suite. Extract repet...
Consistent descriptive identifiers
oven-sh/bunUse camelCase for all variables, parameters, methods, and functions in JavaScript/TypeScript code to maintain consist...
Clear accurate documentation
oven-sh/bunDocumentation should be both technically accurate and contextually helpful for developers. Comments and JSDoc entries...
Always await promises
oven-sh/bunConsistently use the `await` keyword when working with Promise-returning functions to ensure proper execution flow an...
validate LLM reliability
browser-use/browser-useAlways validate LLM capabilities before deployment and implement robust handling for unreliable responses. LLMs can v...
Simplify complex implementations
browser-use/browser-useReplace verbose, complex code structures with simpler, more readable alternatives. Prefer existing methods over inlin...
optimize CI performance
browser-use/browser-useStructure CI workflows to minimize execution time and resource usage through strategic job organization, caching, and...
avoid external test dependencies
browser-use/browser-useTests should not rely on external URLs, live websites, or internet connectivity to ensure reliability, consistency, a...
Structured environment configuration
Homebrew/brewUse structured environment variable handling with explicit validation instead of directly accessing ENV hash. Impleme...
Correct GitHub Actions annotations
Homebrew/brewWhen using GitHub Actions workflow commands for annotations, always include double colons in the syntax (::command::)...
Avoid variable name abbreviations
Homebrew/brewUse complete, descriptive variable names instead of abbreviations to enhance code readability and maintainability. Sh...
Structure for readability
boto/boto3Prioritize code readability by structuring code in a way that makes it easy to understand at a glance. This includes:...
Isolate concurrent resources
boto/boto3Create separate instances of non-thread-safe resources for each thread or process in concurrent applications rather t...
Consistent region configuration
boto/boto3Always maintain consistency in region configurations throughout your application. Instead of hardcoding endpoints, us...
Expose essential configurations
better-auth/better-authCarefully evaluate which configuration options should be exposed to users versus kept internal. Not all configuration...
derive from session context
better-auth/better-authAlways derive sensitive identifiers and permissions from the authenticated session context rather than accepting them...
validate feature configurations
bazelbuild/bazelAlways validate that required features are enabled before using feature-dependent functionality. Feature flags should...
preserve exception causes
bazelbuild/bazelWhen catching an exception and re-throwing a different exception type, always preserve the original exception as the ...
Ensure documentation completeness
bazelbuild/bazelAll code elements should have sufficient documentation to understand their purpose, usage, and context. This includes...
build action separation
bazelbuild/bazelKeep build actions focused on their core responsibility and move complex logic to appropriate abstraction layers like...
Write deterministic tests
Azure/azure-sdk-for-netTests should be deterministic, reliable, and isolated from external dependencies to ensure consistent results across ...
User-friendly configuration values
Azure/azure-sdk-for-netPrefer intuitive, user-friendly values for configuration options over technical "magic strings" or codes that require...
Standardize environment variables
Azure/azure-sdk-for-netEnsure environment variable names are consistently spelled, properly referenced, and follow established naming conven...
Externalize configuration values
Azure/azure-sdk-for-netStore configuration values (URLs, demands, pool names) in centralized variables rather than hardcoding them inline. T...
Use Option combinators
tokio-rs/axumInstead of verbose conditional logic, prefer Rust's Option combinators like map, and_then, and filter for handling po...
Structure errors for safety
tokio-rs/axumCreate specific error types with appropriate status codes while ensuring sensitive details are logged but not exposed...
Minimize memory allocation overhead
tokio-rs/axumOptimize performance by minimizing unnecessary memory allocations and using allocation-efficient APIs. Key practices ...
Lock carefully in async
tokio-rs/axumWhen using locks in async code, follow critical guidelines to avoid deadlocks. Never hold std::sync::Mutex locks acro...
Handle protocol headers properly
tokio-rs/axumWhen implementing network services, especially proxies and protocol handlers, proper HTTP header management is critic...
Validate security-critical inputs
axios/axiosAlways validate and sanitize user-supplied inputs before using them in security-sensitive operations. This helps prev...
Robust Axios Usage in TypeScript
axios/axiosThis review focuses on ensuring robust and type-safe usage of the Axios library in TypeScript codebases. Key recommen...
Proper Error Handling in Axios TypeScript Code
axios/axiosAs a code reviewer, it is important to ensure that Axios-based TypeScript code properly handles and propagates errors...
Extract for better readability
axios/axiosComplex expressions and repeated code should be extracted into well-named variables to improve readability and mainta...
Maintain consistent formatting
aws/aws-sdk-jsEnhance code readability and maintainability by applying consistent formatting practices throughout your codebase: 1...
Validate untrusted inputs
argoproj/argo-cdAlways validate and sanitize user-provided inputs to prevent injection attacks, particularly path traversal vulnerabi...
Simplify code readability
argoproj/argo-cdPrioritize code readability by using clearer control structures, extracting complex expressions into descriptive vari...
optimize algorithmic complexity
argoproj/argo-cdAlways consider computational complexity and performance when implementing algorithms. Look for opportunities to opti...
explicit security controls
argoproj/argo-cdSecurity configurations should use explicit controls and secure defaults rather than implicit permissions or hardcode...
document network requirements
argoproj/argo-cdWhen documenting network-dependent features, explicitly specify all network configuration requirements including prot...
design extensible APIs
argoproj/argo-cdWhen designing APIs, prioritize extensibility and backwards compatibility over convenience. Avoid modifying existing ...
Ensure proper async context
appwrite/appwriteAlways wrap asynchronous operations (await, suspend functions, try-await) in the appropriate language-specific async ...
Cypress test isolation
appwrite/appwriteEnsure end-to-end tests are properly isolated and follow best practices for reliability. Tests should avoid side effe...
Use semantic naming
ant-design/ant-designChoose semantic, non-redundant names that clearly express intent and context. Remove unnecessary prefixes when the co...
Update deprecated demo APIs
ant-design/ant-designDocumentation, demos, and example code should always use current, non-deprecated APIs instead of showing deprecation ...
Test organization standards
ant-design/ant-designWrite tests that are well-organized, maintainable, and reflect real usage patterns. Test names should describe behavi...
Handle optional values safely
ant-design/ant-designAlways provide safe defaults or fallbacks when working with optional or potentially undefined values. Avoid using non...
Deprecated API documentation
ant-design/ant-designWhen documenting deprecated APIs, follow consistent practices to provide clear guidance to developers while maintaini...
Use specific descriptive names
angular/angularChoose specific, meaningful names that clearly communicate purpose rather than generic or ambiguous alternatives. Thi...
Guard nullable value access
angular/angularAlways use appropriate guards or type checks before accessing potentially null or undefined values. Prefer type-safe ...
Configuration opt-in safety
angular/angularWhen introducing new configuration options or making changes that could be disruptive, make them opt-in by default ra...
Choose appropriate presentation formats
angular/angularSelect the most effective format for presenting different types of information in documentation. Use tables for struc...
Choose appropriate algorithms
angular/angularSelect algorithms and data structures that match the problem domain and access patterns rather than using convenient ...
Avoid reactive over-engineering
angular/angularChoose the simplest React primitive that meets your requirements rather than reaching for complex reactive patterns. ...
async resource cleanup
angular/angularAlways ensure proper cleanup of asynchronous resources (subscriptions, timeouts, event listeners) to prevent memory l...
Platform-specific API documentation
alacritty/alacrittyThe provided discussions focus on terminal emulator documentation and configuration issues, but do not contain any co...
consistent error handling
alacritty/alacrittyMaintain uniform error handling patterns throughout the codebase. Avoid mixing different error handling approaches li...
Safe constraint modification sequence
apache/airflowWhen modifying constraints in database migrations, follow a safe sequence of operations to prevent integrity errors: ...
Parameterize similar tests
apache/airflowWrite parameterized tests instead of using for loops or duplicating test code for similar test cases. Using pytest's ...
Optimize collection processing patterns
apache/airflowUse Python's built-in efficient collection processing methods instead of manual implementations. This reduces code co...
Leverage backend API capabilities
apache/airflowWhen consuming APIs in frontend applications, utilize the backend capabilities rather than reimplementing equivalent ...
Explicit version constraints
apache/airflowAlways specify explicit version constraints for dependencies in configuration files (like pyproject.toml), particular...
Explicit over implicit configuration
apache/airflowAlways prefer explicit configuration parameters over inferring behavior from indirect sources like image tags, naming...
Ensure deterministic queries
apache/airflowBuild SQLAlchemy queries that are both efficient and deterministic to prevent unpredictable results and improve perfo...
Document public API boundaries
apache/airflowClearly define and document the boundaries between public and internal APIs to guide developers on proper interface u...
Context-rich log messages
apache/airflowEnsure log messages provide clear context about what happened, potential consequences, and actionable information for...
Consistent technical term translation
apache/airflowWhen localizing an application, maintain consistent conventions for technical terms while respecting language-specifi...
Component reuse first
apache/airflowAlways prioritize reusing existing components before creating new ones. This practice improves codebase consistency, ...
Handle errors gracefully
Aider-AI/aiderAlways implement appropriate error handling to prevent crashes while providing clear feedback to users. Consider thes...
Externalize configuration values
Aider-AI/aiderAlways externalize configuration values rather than hardcoding them directly in the code. This improves maintainabili...
Place configurations appropriately
vercel/aiConfiguration options should be organized based on their nature and scope of use. Place model-specific configurations...
Explicit code organization patterns
vercel/aiMaintain clear and explicit code organization patterns by following these guidelines: 1. Use explicit property visib...
Self-explanatory identifier names
zed-industries/zedChoose identifier names that clearly convey their purpose without requiring users to understand implementation detail...
Respect language-specific conventions
zed-industries/zedAlways adhere to the established formatting and syntax conventions of each programming language while maintaining con...
Maintain style consistency
zed-industries/zedEnsure consistent styling is maintained across related elements in the codebase. This applies to: 1. **Visual assets...
Maintain consistent naming
zed-industries/zedEnsure naming follows consistent patterns throughout the codebase in both style and structure: 1. Use agreed-upon ca...
Hierarchical configuration organization
zed-industries/zedOrganize configuration settings hierarchically by grouping related settings under meaningful namespaces rather than c...
Optimize build configurations
facebook/yogaWhen configuring CMake builds, carefully select compiler and linker flags that optimize for performance while maintai...
Measure optimization trade-offs
facebook/yogaAlways measure and document the impact of performance optimizations before implementing them. When making optimizatio...
Document complex logic
facebook/yogaAdd clear explanatory comments to complex calculations, platform-specific behavior, or non-obvious code sections. Use...
Design familiar APIs
facebook/yogaDesign APIs that align with platform conventions and user expectations rather than creating novel patterns. APIs shou...
consistent formatting choices
facebook/yogaMaintain consistent formatting and structural choices throughout the codebase to improve readability and maintainabil...
Analyze performance trade-offs
facebook/yogaBefore implementing convenience features or making architectural decisions, carefully evaluate their performance impl...
Algorithm specification compliance
facebook/yogaWhen implementing layout algorithms, ensure strict adherence to web standards and specifications, particularly regard...
Add safety checks
facebook/yogaAlways add appropriate safety checks before operations that could result in undefined behavior, null references, or m...
Remove unnecessary configurations
cloudflare/workers-sdkConfiguration files should only include options that are supported in production and work out of the box. Remove conf...
HTTP response construction
cloudflare/workers-sdkUse appropriate HTTP response construction methods and status codes for API endpoints. Prefer `Response.json()` over ...
eliminate redundant null checks
cloudflare/workers-sdkRemove unnecessary null/undefined checks when you already have sufficient validation in place, and use proper type gu...
Wrap throwing operations
cloudflare/workerdAlways wrap potentially throwing operations in try/catch blocks to prevent unhandled exceptions from crashing the app...
Use KJ_UNWRAP_OR pattern
cloudflare/workerdWhen handling potentially null values from functions like `tryParse()` or `tryCast()`, avoid the pattern of checking ...
Simplify async patterns
cloudflare/workerdUse modern promise utilities and clean async patterns instead of manual promise construction. Prefer Promise.withReso...
prefer nullish coalescing operators
cloudflare/workerdUse nullish coalescing operators (`??`) and logical OR with safe defaults (`|| {}`) to handle null and undefined valu...
document security-sensitive features
cloudflare/workerdWhen introducing compatibility flags, feature toggles, or APIs that have security implications, use self-documenting ...
defer async callbacks
cloudflare/workerdAlways ensure callbacks and event emissions are executed asynchronously to maintain proper timing and Node.js compati...
Clear descriptive naming
cloudflare/workerdChoose names that clearly communicate intent without requiring mental gymnastics to understand. Avoid double negative...
Choose efficient algorithms
cloudflare/workerdWhen implementing algorithms, prioritize efficiency in both time and space complexity. Consider these specific optimi...
Centralize error handling
cloudflare/workerdConsolidate error handling logic into central, unavoidable locations rather than scattering it across multiple functi...
Parallelize independent operations
microsoft/vscodeWhen writing concurrent code, always execute independent operations in parallel rather than sequentially to improve p...
Comprehensive JSDoc with examples
microsoft/vscodeWrite thorough JSDoc comments for interfaces, functions, and methods that clearly explain their purpose and behavior....
Avoid CSS !important
microsoft/vscodeUsing `!important` in CSS declarations should be avoided as it makes styles difficult to override and maintain. Inste...
Standardize configuration formats
volcano-sh/volcanoEnsure all plugin configurations follow a consistent, structured format across the codebase to improve maintainabilit...
Secure configuration practices
volcano-sh/volcanoImplement secure configuration practices to protect sensitive data and prevent security vulnerabilities. This include...
Justify default enablement
volcano-sh/volcanoWhen adding new configuration options, carefully consider whether features should be enabled by default. Require expl...
Extract configuration constants
volcano-sh/volcanoAvoid hardcoded values and magic numbers in configuration-related code by extracting them as named constants. This im...
Document technical details clearly
volcano-sh/volcanoEnsure all technical documentation provides clear explanations and follows proper formatting conventions. Technical p...
Secure before deployment
vllm-project/vllmRemove or secure development-specific code before deploying to production environments. Development artifacts like de...
Structured configuration management
vitessio/vitessAvoid using global configuration singletons that rely on string-based lookups, as they lead to brittle code that's ha...
Robust network handling
vitessio/vitessAlways implement proper network timeout handling and address formatting to ensure robust connectivity across differen...
Secure workflow permissions
vitejs/viteDefine explicit and minimal permissions in GitHub Actions workflows to ensure proper operation while maintaining secu...
Restrict server access
vitejs/viteAlways configure server security settings with explicit allowed lists rather than permissive values. Using `true` for...
comprehensive validated examples
vlang/vDocumentation examples should be self-sufficient, comprehensive, and use proper syntax tags to enable automated valid...
Avoid breaking API changes
vlang/vWhen modifying existing public APIs, always maintain backward compatibility to avoid breaking existing users. Breakin...
Short-circuit evaluation strategies
astral-sh/uvWhen implementing search or traversal algorithms, use short-circuit evaluation strategically to avoid unnecessary com...
Optimize cache sharing strategies
astral-sh/uvSelect the appropriate cache sharing approach based on your execution environment to maximize performance and efficie...
Follow established naming conventions
astral-sh/uvAdhere to established naming conventions for files, variables, functions, and configuration options to maintain consi...
Enforce strong optional types
astral-sh/uvUse strong typing and early validation to handle optional values and prevent null-related issues. Prefer enums and sp...
Declarative constraints over runtime
astral-sh/uvDesign APIs that enforce constraints through type systems and declarative mechanisms rather than runtime checks. This...
prefer efficient operations
Unstructured-IO/unstructuredChoose efficient operations and algorithms over expensive alternatives, particularly when processing data or performi...
API examples completeness
Unstructured-IO/unstructuredEnsure all API code examples include all required parameters with correct placeholder values. Incomplete examples lea...
use meaningful error types
unionlabs/unionReplace generic exceptions with context-specific error types that provide meaningful information about what went wron...
use Effect Option consistently
unionlabs/unionReplace null, undefined, and error throwing with Effect's Option type for handling potentially missing values. This p...
Use configuration service injection
unionlabs/unionReplace mutable singletons and getter functions with dependency injection services for configuration-dependent compon...
SQL query best practices
unionlabs/unionAlways include ORDER BY clauses in paginated queries to ensure consistent results across multiple requests. Without e...
Reuse existing API utilities
unionlabs/unionBefore implementing custom API utilities, serializers, or type identification methods, check if equivalent functional...
organize code for readability
unionlabs/unionStructure code to maximize readability and maintainability through clear organization patterns. Use top-level control...
Maintain naming consistency
unionlabs/unionEnsure consistent terminology and naming conventions across the entire codebase. Use the same identifier names for th...
Choose appropriate async primitives
unionlabs/unionSelect async/concurrency primitives based on your specific usage patterns and requirements rather than defaulting to ...
avoid hardcoded configuration
unionlabs/unionAvoid hardcoding configuration values directly in code. Instead, make parameters configurable through CLI arguments, ...
avoid error display duplication
unionlabs/unionWhen using thiserror for error handling, avoid displaying source errors in both the error message and the source attr...
Prevent object recreations
shadcn-ui/uiAvoid creating new objects and functions repeatedly during renders to reduce memory pressure and improve performance....
Leverage framework defaults
shadcn-ui/uiAvoid redundant or unnecessary configuration by understanding and utilizing default behaviors provided by frameworks ...
Complete optional chaining
shadcn-ui/uiWhen using optional chaining (`?.`), ensure that **all subsequent operations** in the chain are also protected from n...
Complete configuration paths
shadcn-ui/uiAlways verify that configuration files include all necessary file paths and extensions, particularly for framework-sp...
Preserve naming consistency
microsoft/typescriptMaintain consistent naming patterns and casing across all related code entities to ensure clarity and prevent errors....
Eliminate unnecessary constructs
microsoft/typescriptRemove redundant or unnecessary code constructs to improve readability and maintainability. This includes avoiding em...
Structure documentation logically
astral-sh/tyOrganize documentation sections and content to match user mental models and workflows, not internal technical impleme...
Ensure CI dependency reliability
astral-sh/tyCI workflows should use the most current versions of dependencies and ensure all required tools are available. Avoid ...
Use proper PostgreSQL types
twentyhq/twentyLeverage PostgreSQL's native data types and features instead of generic alternatives to improve performance, type saf...
Use proper null utilities
twentyhq/twentyUse dedicated null checking utilities like `isDefined` or `isUndefinedOrNull` instead of generic type coercion functi...
Security-critical code review
twentyhq/twentyChanges to security-sensitive areas like authentication, input validation, and business logic require extra scrutiny ...
Choose appropriate concurrency patterns
twentyhq/twentySelect concurrency mechanisms that align with your system architecture and established codebase patterns. Avoid using...
Avoid repeated expensive operations
twentyhq/twentyReplace repeated expensive operations like `find()`, `filter()`, or `sort()` with pre-computed maps or cached results...
Validate configuration structures
vercel/turborepoEnsure configuration files and schemas adhere to their expected structure, location, and uniqueness constraints. When...
Use functional null handling
vercel/turborepoLeverage Rust's functional operators for handling nullable and optional values. Instead of using unwrap() or explicit...
Use affected mode
vercel/turborepoOptimize CI pipelines by running tasks only on packages affected by code changes. Use the `--affected` flag in Turbor...
Standardize package manager commands
vercel/turborepoEnsure all package manager commands in documentation and CI/CD scripts follow the correct syntax for the specific pac...
Semantic naming conventions
vercel/turborepoUse names that clearly convey the purpose and content of variables, parameters, and properties. When working with obj...
Minimize lock duration
vercel/turborepoWhen using locks in asynchronous code, minimize the scope and duration for which locks are held, especially across `....
Document configuration alternatives
vercel/turborepoWhen documenting commands or tools that can be executed in different ways based on configuration settings (like globa...
Document cache strategies
vercel/turborepoAlways provide clear documentation and implementation for caching strategies, including key generation, invalidation ...
Write explicit concrete tests
tree-sitter/tree-sitterTests should be written explicitly with concrete examples and clear assertions rather than being generated programmat...
optimize parser development strategy
tree-sitter/tree-sitterWhen developing parsers or grammars, apply strategic optimization by prioritizing commonly used language features and...
optimize dependency configurations
tree-sitter/tree-sitterWhen configuring dependencies in package manifests, prioritize efficiency and maintainability by avoiding redundant d...
API pattern consistency
tree-sitter/tree-sitterWhen designing new API functions, maintain consistent patterns across the codebase and avoid creating precedents that...
Remove unused code elements
traefik/traefikEliminate unnecessary code elements including unused parameters, struct tags, methods, and dead code to improve code ...
descriptive contextual logging
traefik/traefikLog messages should be descriptive, contextual, and provide actionable information. Include relevant context such as ...
Optimize job structure
tokio-rs/tokioStructure CI jobs for clarity, parallelism, and efficiency. Each job should have a single, well-defined purpose to pr...
Optimize CI job structure
tokio-rs/tokioStructure your CI workflows to maximize performance and clarity. Each job should have a single, clear responsibility ...
Minimize unsafe code
tokio-rs/tokioWhen writing code that requires unsafe operations, follow these critical security practices: 1. Minimize the scope o...
Clear command documentation
tokio-rs/tokioWhen documenting shell commands in technical documentation, use the `shell` language identifier instead of `bash` as ...
Thread-safe resource sharing
huggingface/tokenizersWhen sharing mutable data between threads, use the `Arc
Pythonic API design
huggingface/tokenizersDesign APIs that follow Python language conventions and idioms rather than blindly mirroring the underlying implement...
Purpose-indicating descriptive names
huggingface/tokenizersChoose names for variables, methods, parameters, and fixtures that clearly communicate their purpose, content, and be...
Optimize workflow triggers
huggingface/tokenizersConfigure CI workflows with targeted triggers and path filters to balance thoroughness with efficiency. Run critical ...
Modular model components
huggingface/tokenizersDesign machine learning model code with clear component boundaries and proper separation of concerns. Each component ...
Manage version constraints
huggingface/tokenizersWhen configuring dependency version constraints in project files, follow these principles: 1. Be explicit about vers...
Technical precision matters
hashicorp/terraformWhen documenting algorithms, data structures, and computational processes, use precise and objective language rather ...
Document implementation rationale
microsoft/terminalAdd comments that explain the reasoning behind non-obvious code decisions, technical constraints, or complex logic, w...
Clear accurate error messages
microsoft/terminalError messages should be clear, accurate, and contextually appropriate to help users understand what went wrong and h...
Validate tensor inputs safely
tensorflow/tensorflowWhen handling tensor inputs that may contain invalid values, use transformational approaches rather than conditional ...
Separate test data
tensorflow/tensorflowLarge test data should be separated from test logic to improve readability and maintainability. Move test data into s...
Use dedicated configuration files
temporalio/temporalAlways use dedicated configuration files for specific configuration needs rather than modifying core build or system ...
Structured contextual logging
temporalio/temporalAlways use structured logging with appropriate tags instead of string concatenation or formatting. Include relevant c...
Operation order affects correctness
temporalio/temporalWhen implementing algorithms that involve multiple operations (like iteration, validation, and execution), the order ...
Minimize code nesting depth
temporalio/temporalReduce cognitive load and improve code readability by minimizing nested code blocks. Prefer early returns and flatten...
Context-aware network calls
temporalio/temporalAlways propagate context through network calls to ensure proper cancellation, timeout handling, and tracing. For HTTP...
Use structured API parameters
gravitational/teleportWhen designing APIs with multiple related parameters, especially optional ones like filters, sorting, and pagination ...
Use semantically clear names
gravitational/teleportChoose names that clearly convey their purpose, scope, and meaning to reduce ambiguity and improve code maintainabili...
Use descriptive semantic names
gravitational/teleportChoose descriptive, semantic names that clearly convey purpose and meaning rather than generic or ambiguous identifie...
Provide contextual error messages
gravitational/teleportError messages should be specific, contextual, and use appropriate error creation functions to help users understand ...
Plan encryption key recovery
gravitational/teleportAlways implement recovery mechanisms and plan for key rotation when designing encryption systems. Encryption key fail...
Follow platform naming standards
gravitational/teleportAdhere to established naming conventions specific to each platform, framework, or technology being used. Different pl...
Avoid overly broad permissions
gravitational/teleportUse specific, scoped permissions instead of wildcards to prevent unintended access to sensitive resources. Wildcard p...
API parameter encapsulation
gravitational/teleportWhen designing API methods that accept multiple related parameters (especially filters, search criteria, or configura...
Training-aware ML APIs
tensorflow/swiftDesign machine learning APIs with explicit parameters for distinguishing between training and inference phases rather...
Swift idiomatic naming
tensorflow/swiftFollow Swift's naming conventions to write more readable, maintainable code. The Swift language emphasizes clarity an...
Provide comprehensive examples
tensorflow/swiftAPI documentation should include complete examples that demonstrate all key usage patterns. When documenting related ...
Generic algorithm design
tensorflow/swiftWhen implementing generic algorithms in Swift, follow these best practices to improve code clarity and performance: ...
Format for readability
tensorflow/swiftCode should be formatted to optimize readability. Apply these key practices: 1. **Maintain reasonable line length** ...
Follow Swift naming conventions
tensorflow/swiftEnsure code follows established Swift naming conventions and remains consistent with domain terminology: 1. Use stan...
Document API stability
tensorflow/swiftWhen working with AI frameworks and machine learning libraries, clearly document the stability state of APIs being us...
API version management
SWE-agent/SWE-agentWhen integrating with external APIs, explicitly handle version differences and use parameterized configurations inste...
preserve user input focus
sveltejs/svelteWhen implementing reactive state updates that affect input elements, always check if the user is currently interactin...
Multi-indicator configuration detection
sveltejs/svelteWhen detecting configuration states, use multiple indicators rather than relying on a single source of truth, especia...
Descriptive migration comments
sveltejs/svelteWhen adding migration task comments, always include specific details about why manual intervention is required rather...
async cleanup safety
sveltejs/svelteEnsure async operations include proper safety checks to prevent race conditions, memory leaks, and inconsistent state...
analyze transitive dependencies
sveltejs/svelteWhen implementing dependency analysis algorithms, ensure comprehensive tracking of both direct and transitive depende...
Use parameter-based paths
supabase/supabaseWhen designing API routes and interfaces, always use parameter-based path syntax instead of hardcoded literals. This ...
Use configuration over hardcoding
supabase/supabaseAlways use configuration constants instead of hardcoding values directly in the code. This improves maintainability a...
Prevent re-render triggers
supabase/supabaseAvoid creating new object/array references in component render functions and carefully manage state updates to preven...
Explicit role security management
supabase/supabaseAlways be explicit about role privileges when configuring database security. Remember that both `authenticated` and `...
Explicit null handling
supabase/supabaseUse explicit patterns when dealing with potentially null or undefined values to prevent runtime errors and improve co...
Database entity configuration
supabase/supabaseConfigure database entities with appropriate defaults and clear type distinctions. For triggers, prefer AFTER/ROW ove...
Centralize configuration values
supabase/supabaseExtract and centralize configuration values instead of duplicating or hardcoding them throughout the codebase. This i...
Abstract user-facing errors
supabase/supabaseError messages displayed to end users should abstract away implementation details while providing actionable informat...
prefer lazy computation
browserbase/stagehandAvoid precomputing expensive operations when they may not be needed, especially for large datasets. Instead, compute ...
Configure workflow triggers
browserbase/stagehandEnsure GitHub Actions workflows are triggered appropriately by configuring branch patterns and path filters to balanc...
abstract environment variables
browserbase/stagehandAvoid directly referencing environment variables throughout your codebase. Instead, abstract them into named constant...
Standardize configuration formats
spring-projects/spring-frameworkUse consistent, explicit, and well-documented formats in all configuration files to improve readability and prevent m...
Package null-safety annotations
spring-projects/spring-frameworkAll package-info.java files must include both @NonNullApi and @NonNullFields annotations to establish null-safety at ...
Optimize CI environment configuration
spring-projects/spring-frameworkWhen configuring CI environments, carefully evaluate whether default dependency versions are sufficient for your proj...
Leverage Kotlin null-safety
spring-projects/spring-frameworkUtilize Kotlin's null-safety features effectively to create cleaner, more robust code: 1. For class properties that ...
Database-agnostic SQL syntax
spring-projects/spring-frameworkWrite SQL statements that conform to standard SQL rather than relying on vendor-specific dialects to ensure portabili...
Clone network headers carefully
spring-projects/spring-frameworkWhen working with HTTP or WebSocket headers in networking code, be cautious about header manipulation, cloning, and l...
Validate nulls properly
spring-projects/spring-bootAlways use appropriate null validation mechanisms to prevent NullPointerExceptions and ensure code robustness. For s...
Reference existing configurations
spring-projects/spring-bootWhen setting up configuration files, reference existing configuration sources rather than duplicating values or logic...
Verify CI build consistency
apache/sparkEnsure CI pipelines thoroughly verify build outputs and maintain consistency across different build tools and configu...
use modern Java syntax
apache/sparkPrefer modern Java language features and constructs to write more concise, readable code. Since Apache Spark 4.0.0, t...