Skills Library

Prioritize clean code structure and readability in AI/ML codebases by avoiding inline conditionals, using d...

Prioritize algorithmic efficiency by choosing operations and data structures that minimize computational co...

All public items, struct fields, and methods must have comprehensive documentation. When implementing web s...

Break long lines and complex structures across multiple lines to improve code readability. Follow these gui...

All modules containing functions should have corresponding .mli files with comprehensive documentation. The...

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

Avoid hardcoding specific device types like 'cuda' in AI code. Instead, use device-agnostic approaches such...

Enforce each function’s documented input contract with early, explicit checks; raise specific exceptions wi...

Ensure consistent patterns, formatting, and conventions throughout the codebase. Inconsistencies in code st...

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

Use precise, natural language in documentation to improve clarity and readability. Focus on accurate word c...

When implementing resource cleanup logic, especially disposers for explicit resource management, always des...

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...

Rule: choose concise, semantically accurate, and responsibility-respecting names for identifiers (variables...

Rule: Fail fast, validate assumptions, and distinguish user cancellation. Motivation - Hidden or silently ...

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...

Adopt naming conventions that are (1) case-consistent by identifier kind and (2) semantically self-document...

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

When adding or updating configuration-related docs (env vars, config files, feature/transport flags, and de...

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

For every algorithmic change (and every public function/class), require automated tests that lock in both c...

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...

When writing tests, ensure they (1) match the scenario name and input data, (2) exercise behavior through t...

Adopt consistent, explicit identifier naming across diagrams and TypeScript APIs. **Rules** 1) **Diagram i...

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 ...

Ensure every `curriculum/structure/blocks/*.json` file matches the CI-validated schema and constraints. - ...

When writing technical curriculum/docs, ensure the content is (a) accurate, (b) unambiguous about what lear...

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...

When a doc section introduces a new configuration option or feature, include accurate version metadata (Cel...

When handling errors, ensure (1) you don’t accidentally change which exception path fires, (2) recovery/cle...

Prefer eliminating work that can’t affect observable behavior and prevent resource retention in hot paths. ...

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 changing or adding public API in schema/validation libraries, prioritize a stable, user-controlled sur...

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

Ensure components explicitly initialize reactive state, manage input/keybinding lifecycle, and decide wheth...

Tests should follow consistent structure and provide high-signal coverage. Apply these rules: 1) Put tests...

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...

When code can run on both main and IO threads, require an explicit ownership + synchronization rule for eve...

Adopt explicit, consistent nullability contracts for pointer/optional-field parameters and honor them at ev...

When adding performance optimizations (prefetch/batching/fast paths), make them bounded, gated, and semanti...

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 improving performance, make sure code neither (a) fetches too much data, nor (b) does the same expensi...

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

Use self-documenting identifiers: variable/function/class names should explain intent without relying on co...

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 ...

Use consistent, typed exceptions at the point of failure, with structured context, and never rely on unchec...

When transforming data to/from the API, always implement the backend’s explicit contract: ordering invarian...

Adopt a “type-safe, clean, DRY” style for readability and maintainability. - Prefer module-scope imports: ...

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...

Ensure GitHub Actions CI runs are repeatable, targeted, and don’t rely on brittle hacks. 1) Run tests usin...

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

When updating code, prioritize maintainability and readability by removing duplicated blocks, eliminating m...

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...

When adding/changing tests, optimize for (1) clear intent, (2) stability against refactors, and (3) determi...

When working with concurrency (threads/async), ensure code is safe under parallel invocations and does not ...

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...

Define a clear, minimal plugin contract and loader API for all external/ built-in plugins. Motivation: plug...

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...

When changing concurrency/background execution, ensure (a) state is isolated per thread/consumer/instance, ...

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...

Standardize error handling so failures remain diagnosable and user-facing messages are complete. Apply the...

Default to the cheapest behavior: gate expensive work behind explicit options or conditions, and keep the p...

When writing tests, validate the *actual user-visible behavior and structured error data*, not just a subst...

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...

Ensure mutable shared data is never exposed or accessed without explicit synchronization. When data crosses...

Centralize repeated UI logic and prefer modern, consistent JS style. When you see duplicated logic, ad-hoc ...

Adopt a consistent rule: anything coming from persistence, other platforms/accounts, terminal escape sequen...

When code performs expensive IO/compute or reacts to frequent events, (1) gate side effects to meaningful s...

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...

Adopt a “review-first” style for complex C code: keep control flow and conditions small, make side effects ...

When implementing commands with numeric failure modes (overflow, out-of-range, NaN/Inf) or multi-option par...

Apply a single security rule: validate arity, lengths, ranges, and invariants before using inputs to index ...

Ensure comments and public-facing documentation precisely match the actual behavior and contract. Apply th...

When adding or evolving APIs (commands, module interfaces, persistence callbacks), make the contract explic...

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

Adopt a single error-handling standard across LLM/provider layers: 1) Retry only transient failures (inclu...

All documentation must accurately reflect product/API behavior, use exact feature names, and be unambiguous...

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

Keep reusable code clean and production-ready: reusable/algorithmic functions should be side-effect free (n...

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...

Security-sensitive code must ensure (1) the correct auth path is used without accidental overrides, (2) sen...

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...