Skills Library

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

Avoid duplicating similar algorithmic logic across multiple functions by consolidating them into generic, t...

All AI model configuration parameters must be verified against official provider documentation before mergi...

Structure documentation to prevent information overload and improve readability by using appropriate organi...

Choose names that accurately reflect the actual functionality, purpose, or semantic meaning rather than usi...

When implementing feature-gated fields, always preserve existing field values when the feature gate is disa...

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

Ensure tests cover not only the happy path but also edge cases, error scenarios, and complete workflows. Ma...

Design command-line interfaces with consistent flag semantics and leverage framework features for validatio...

Properly sanitize or escape all user-provided inputs before using them in sensitive contexts to prevent inj...

Avoid catch-all patterns and implicit error handling. Handle each error case explicitly, use the ? operator...

Choose names that clearly communicate intent and purpose rather than being generic, abbreviated, or potenti...

Names should be descriptive and unambiguous, clearly communicating their purpose and intent. Avoid abbrevia...

Choose variable, method, class, and parameter names that clearly communicate their purpose and avoid ambigu...

When writing tests for Home Assistant integrations, mock external library dependencies rather than Home Ass...

Names should accurately reflect their purpose, behavior, and semantic meaning to avoid confusion and improv...

Minimize memory allocations, data copying, and expensive operations by implementing early exits, using move...

Add explanatory comments and documentation for complex logic, non-obvious code behavior, method parameters,...

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

Write code that prioritizes readability and clarity over minor optimizations or clever shortcuts. When face...

Always handle null and undefined values explicitly through proper type declarations and validation patterns...

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

Write code that clearly expresses intent through explicit patterns, simplified logic, and readable structur...

Write code that prioritizes readability and explicitness over brevity. This includes using explicit type co...

Configuration documentation should be precise, specific, and include helpful context for users. Avoid vague...

Maintain code clarity by using appropriate type declarations and parameter passing conventions: 1. **Prefe...

Structure code based on what it does rather than how it's implemented. Group related functionality together...

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

Documentation should convey purpose and behavior, not just replicate code structure. Each docblock should e...

Ensure that shared mutable state is properly protected against concurrent access to prevent race conditions...

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

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

When implementing algorithms, prioritize simplicity and maintainability over premature optimization. Comple...

Always implement robust null handling patterns to prevent unexpected behavior and crashes. Consider all edg...

Identify and extract duplicated code into reusable functions or move common fields to parent structures. Th...

Write code that prioritizes clarity and simplicity over cleverness. This improves maintainability and reduc...

Choose specific, descriptive names for variables, methods, types, and other identifiers that clearly commun...

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

When defining configuration schemas, use consistent patterns for safe property access, async resolution, an...

Implement proper type conversion and validation when working with different database systems to prevent run...

Use explicit types instead of `auto` unless the type is obvious from the right-hand side of the assignment ...

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

Prioritize code simplification by removing unnecessary complexity, avoiding duplication, and leveraging exi...

Always define technical terms and concepts explicitly in documentation rather than assuming reader knowledg...

Always implement comprehensive error handling for asynchronous operations, external API calls, and database...

Optimize performance by minimizing unnecessary memory allocations and system calls. Key practices: 1. Avoi...

When integrating with AI models and LLMs, structure your code to properly handle model responses, separate ...

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

Choose efficient data structures and algorithms to minimize computational overhead and improve performance....

Choose names that clearly describe the purpose, behavior, or content of variables, methods, and classes. Av...

Handle null and undefined values safely by using appropriate fallback patterns, validating critical paramet...

Maintain clean code organization by moving implementation details to appropriate locations, extracting reus...

Manage dependencies at the top level using `` to ensure version consistency across mo...

Implement robust error handling that provides fallback mechanisms, ensures proper resource cleanup, and del...

Cloud resources should be configured to restrict public network access by default to minimize potential att...

Break down complex logic into small, well-named functions that each do one thing well. This improves code r...

Maintain consistent naming patterns throughout the codebase to improve readability and reduce confusion: 1...

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

Ensure configuration options are handled uniformly across all API endpoints and providers. Configuration sh...

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

Always validate environment variables before use and implement proper fallback strategies. For required var...

Always implement graceful error handling for resource lookups, data parsing, and system operations. Catch s...

When implementing or modifying API endpoints, ensure consistency across related routes by checking: 1. Par...

Eliminate unnecessary operations and choose appropriate data structures to improve algorithmic efficiency. ...

Use clear, consistent, and semantic naming patterns across your codebase to improve readability and maintai...

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

Remove redundant code patterns that add complexity without value. This includes: 1. Duplicate code blocks ...

When you identify duplicate code blocks, complex logic that can be simplified, or functionality that doesn'...

Replace hardcoded values and magic numbers in AI model code with named constants or configuration parameter...

Structure test cases for maximum readability and maintainability by following these principles: 1. Organiz...

Configuration parameters should be properly validated with appropriate defaults and clear handling of edge ...

Names should be descriptive and specific enough to clearly communicate their purpose and avoid confusion. T...

Properly propagate errors to callers with sufficient context rather than handling them prematurely or hidin...

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

Apply standardized error handling patterns across your codebase for improved reliability and debugging. For...

Choose names that clearly indicate their purpose and behavior rather than using generic or ambiguous terms....

When designing configuration schemas and fields, carefully consider their placement, validation, and long-t...

Prefer modern JavaScript null-safe operators over verbose conditional checks to improve code readability an...

Choose straightforward, readable code patterns over complex or clever alternatives. This improves maintaina...

Avoid hard-coding model names and provider-specific configurations throughout the codebase. Instead, implem...

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

Replace `.unwrap()` and `panic!()` calls with proper error handling to prevent crashes and improve robustne...

Design APIs with appropriate parameter types, place conversion functions as trait implementations in the co...

When refactoring code to use async/await, ensure complete and consistent adoption throughout the function o...

Choose meaningful, self-explanatory names for variables, parameters, properties, and methods that clearly c...

Names should clearly and accurately describe their purpose, avoiding abbreviations, acronyms, and misleadin...

Choose clarity and simplicity over clever or complex constructs. Avoid unnecessary abstractions, complex fu...

Avoid using `failwith`, `assert false`, and similar blunt error handling mechanisms that can turn recoverab...

Documentation should be concise, focused, and maintainable. Follow these principles: 1. Keep examples shor...

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

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

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

Ensure thread-safe access to shared state by using appropriate synchronization mechanisms and atomic operat...

Use Kotlin-specific constructs and syntax patterns instead of Java-style code to improve readability and ma...

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

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

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

Prioritize memory allocation minimization through buffer reuse, pre-allocation, and efficient data structur...

Break down complex inline conditions and nested logic into separate, well-named functions or simpler expres...

Choose names that clearly communicate purpose and accurately represent what they describe. Avoid ambiguous ...

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

Always explicitly specify configuration values rather than relying on defaults or implicit behavior. Poetry...

Variable, method, and class names should accurately reflect their actual behavior and purpose. Misleading o...

Write code that prioritizes readability and explicitness over cleverness or brevity. This includes several ...

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

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

Always provide explicit default values for configuration options to improve code readability and maintainab...

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

Every Vue component (.vue file) that is created or modified must have at least one corresponding unit test ...

Choose descriptive, specific names that clearly communicate intent and behavior rather than generic or ambi...

Names should accurately reflect the actual behavior, purpose, and scope of functions, variables, and classe...

Choose names that clearly convey their purpose, role, and meaning while maintaining consistency with establ...

Always use safe access methods when working with potentially null or undefined values. Use .get() for dicti...

Ensure comprehensive documentation for AI/ML provider integrations that covers all usage patterns, uses pre...

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

Keep related documentation content together on a single page rather than fragmenting it across multiple pag...

Ensure API documentation provides comprehensive, accurate information including limitations, complete workf...

Choose names that accurately reflect the purpose, scope, and semantics of variables, methods, and classes. ...

Remove unnecessary code, operations, and annotations that don't add value. This includes redundant type ann...

Prioritize code simplicity and readability by leveraging standard library functions, improving control flow...

Code should include explanatory comments that help future maintainers understand complex logic, design deci...

Always wrap multiple related database operations in a transaction to ensure data consistency and prevent pa...

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

Identify and extract repeated code patterns into well-named functions to improve readability, maintainabili...

Actively identify and eliminate code duplication by extracting repeated logic into reusable functions, usin...

Write code with clear structural organization that enhances readability and maintainability. Extract duplic...

Place code at the appropriate abstraction level and extract complex logic to dedicated modules. Large files...

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

Prioritize reducing memory allocations and choosing efficient data structures to improve performance. Avoid...

All code paths, error conditions, and edge cases must have corresponding unit tests to ensure robust functi...

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

Only initialize configuration-dependent features, systems, or resources when the relevant settings, flags, ...

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

Actively identify and eliminate code duplication to improve maintainability and reduce the risk of inconsis...

Always provide clear feedback when operations fail, even when continuing with fallbacks or alternative appr...

Leverage modern JavaScript operators and patterns for cleaner, more robust null and undefined handling. Thi...

Identify and eliminate unnecessary memory allocations in performance-critical code paths. This includes pre...

Production code should be free from debugging artifacts that reduce readability and maintainability. Remove...

When you notice code patterns being repeated across functions or methods, extract the common logic into sep...

Choose names that clearly communicate purpose, content, and intent. Avoid generic or ambiguous identifiers ...

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

Always use the `.get()` method with appropriate default values when accessing dictionaries instead of direc...

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

Always implement comprehensive authorization checks that verify user permissions at the appropriate hierarc...

When implementing new functionality or modifying existing code, always add corresponding tests that compreh...

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

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

When performing multiple related database operations, use transactions and proper error handling to maintai...

Ensure test suites provide comprehensive coverage by including edge cases, different input scenarios, and a...

Choose names that clearly describe their purpose, behavior, and data type rather than generic or ambiguous ...

Error messages should provide specific context and actionable guidance to help developers understand and re...

Ensure consistent and appropriate dependency version constraints across all package.json files. Use flexibl...

Choose the correct exception handling mechanism and type based on the error condition's nature and audience...

Choose clear, self-explanatory names that prioritize readability over brevity. Avoid abbreviations, obscure...

Always ensure proper isolate lock management and thread-safe access patterns when working with JavaScript c...

Replace Python loops and list comprehensions with vectorized operations when processing tensors or performi...

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

When sharing data across goroutines, always use proper synchronization mechanisms to prevent race condition...

Use descriptive, semantically clear names that follow consistent patterns throughout the codebase. Names sh...

Use clear, descriptive names while avoiding redundant qualifiers. Choose full words over abbreviations unle...

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

Choose names that clearly communicate purpose, intent, and functionality rather than generic or abbreviated...

When implementing algorithms with nested loops or recursive operations, carefully analyze the computational...

Write code that is easy to read and understand by avoiding unnecessary complexity in structure and logic. T...

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

Choose names that clearly express intent and behavior while avoiding ambiguity. Identifiers should communic...

Documentation should include all necessary information for users to successfully implement features. This i...

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

Always consider the time and space complexity implications of your code. Choose data structures and algorit...

Libraries should never panic as this can crash applications using the library. Always return a `Result` typ...

Choose clear, self-documenting names for variables, methods, parameters, and properties that explicitly con...

Choose efficient algorithms and data structures to improve performance and reduce computational overhead. T...

Identify and cache the results of expensive operations that are computed repeatedly with the same inputs. T...

Choose names that accurately reflect the behavior and purpose of code elements. Names should be semanticall...

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

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

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

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

Avoid duplicate function calls, repeated tensor operations, and redundant computations that can significant...

Replace `.unwrap()` calls and sentinel values with safe null handling patterns to prevent runtime panics an...

Identify and eliminate computational work that serves no purpose, particularly for inactive, hidden, or irr...

Choose simple, readable code patterns over complex alternatives. Avoid unnecessary complexity that doesn't ...

When modifying public APIs, always preserve backwards compatibility to avoid breaking existing consumers. P...

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

Choose descriptive names that clearly convey purpose while avoiding conflicts with existing APIs, built-in ...

Ensure proper dependency version specification and compatibility management in package.json files. Use expl...

Extract repetitive or complex code into reusable functions, components, or custom hooks. This improves code...

Structure tests to maximize clarity and maintainability by: 1. Placing related tests together in appropriat...

When implementing AI operations that involve matrix multiplication or neural network components, explicitly...

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

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

Documentation comments should be accurate, concise, and add genuine value rather than restating obvious cod...

Ensure proper metrics registration and lifecycle management to maintain observability system stability. Han...

Ensure configuration options that are mutually exclusive are properly validated with clear, actionable erro...

Prefer explicit null and undefined handling over optional or nullable types. When possible, provide default...

Ensure proper classification and versioning of package dependencies in package.json files. Dependencies sho...

Choose variable and function names that clearly communicate their purpose, type, and context. Avoid abbrevi...

Ensure all code examples and documentation maintain consistent formatting standards, use descriptive variab...

Use explicit and clear patterns when handling null/None values to improve code readability and maintainabil...

Maintain consistent patterns across all API endpoints, including naming conventions, response structures, H...

Maintain clear separation between different stages of configuration processing by creating dedicated struct...

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

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

Document code following Go's official documentation style guide (https://tip.golang.org/doc/comment). All e...

Choose identifier names that clearly communicate their purpose while maintaining an appropriate balance bet...

Always write assertions that verify specific, expected values rather than simple existence or boolean check...

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

Always perform explicit null and undefined checks before processing values, and use the nullish coalescing ...

Ensure all API endpoints have complete and accurate OpenAPI annotations to support proper SDK generation an...

Error messages should be specific, actionable, and include context that helps developers understand and fix...

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

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

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

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

Write concise, efficient tests by eliminating repetitive code and combining related test cases. Avoid verbo...

Maintain consistent naming patterns and terminology across the codebase to reduce cognitive load and improv...

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

Always use the project's structured logger instead of direct console methods (`console.log`, `console.error...

Always use optional chaining and nullish coalescing operators to prevent runtime errors when accessing prop...

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

Only mark functions as `noexcept` when you can guarantee they won't throw exceptions under any circumstance...

Use direct `process.env` access and standardized configuration management instead of custom environment var...

Choose names that clearly describe the purpose, behavior, and content of functions, variables, and constant...

Follow established naming patterns and conventions consistently throughout the codebase. This includes usin...

Follow the DRY (Don't Repeat Yourself) principle by extracting repeated code patterns into helper functions...

API fields must be comprehensively documented with clear behavior specifications, format constraints, and i...

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

Ensure configurations are conditional, context-aware, and resilient. Use feature flags to control functiona...

Use modern collection creation methods instead of legacy alternatives for improved readability and concisen...

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

Write code that prioritizes clarity and maintainability over brevity. This involves several key practices: ...

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

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

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

Keep code well-organized by separating interface from implementation, managing dependencies properly, and f...

Wrap all sensitive data fields in Secret<> types to prevent accidental exposure through logs, debug output,...

Ensure documentation is clear, precise, and consistently formatted. Key practices include: 1. **Be explici...

When multiple operations can execute concurrently (e.g., multiple keystrokes in the same React event loop, ...

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

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

Maintain consistent naming conventions throughout the codebase by following established patterns and avoidi...

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

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

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

Maintain documentation with a single source of truth to prevent inconsistencies and reduce maintenance burd...

Implement comprehensive null safety patterns to prevent runtime errors and ensure predictable behavior. Fol...

When functions may not return valid values, use `std::optional` or `absl::optional` instead of raw types th...

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

When integrating with external AI libraries, models, or services, handle optional dependencies gracefully t...

Always perform explicit authorization checks rather than assuming existing security controls are sufficient...

Choose names that clearly convey their purpose and avoid ambiguous identifiers that can be misinterpreted. ...

All public APIs must have comprehensive and clear documentation that helps developers understand functional...

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

Use Python's expressive features to write cleaner, more maintainable code by reducing nesting and improving...

Use descriptive, unambiguous variable and function names that clearly convey their purpose and avoid confli...

Create reusable components instead of duplicating similar code patterns. When you find yourself writing sim...

Always validate environment variables and provide appropriate fallbacks when using them for configuration. ...

Large files with multiple responsibilities should be broken down into focused, single-responsibility module...

Always validate inputs and preconditions before executing database operations, and fail explicitly rather t...

Always use centrally supplied loggers from the invocation context or configuration instead of creating new ...

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

Embrace Python's idiomatic programming style to make your code more readable, concise, and maintainable. Fo...

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