Duplication & Complexity rules

Store repeated string literals in constants or variables to improve maintainability and reduce redundancy.

Identify cases where `x is None` or `x is not None` is used redundantly when `x` is always or never `None`. This may indicate a deeper logic issue.

Identify functions that return the same value regardless of input. This may indicate poor design or a logic error.

Remove unnecessary calls to `.toList()` when using the spread operator (`...`) as it is already designed to work with iterable collections.

Remove unnecessary `.toList()` calls when using the spread operator (`...`) to avoid redundant operations.

Provide a single permission check API (e.g., can(user, action, resource)) and reuse it across layers.

Copy-pasting code can lead to errors where getters or setters access the wrong fields. Always verify that properties interact with the expected fields.

In JS/TS workspaces, imports must use workspace package names (as defined in each package.json and exports) rather than relative paths crossing package boundaries.

Verify that LINQ queries are not excessively long. Break complex queries into smaller, more understandable expressions.

Detect deeply nested conditionals and suggest using guard clauses (`return unless condition`) instead to improve readability.

Ensure that methods perform a single, well-defined task. Large methods should be refactored into smaller, focused methods.

Check if the method, variable, or class title contains redundant context (e.g., using 'carDrive()' when 'drive()' would suffice). Ensure the title is concise and avoids repetition of surrounding context.

Ensure that explicit null checks are not used with `instanceof`, as `null` is never an instance of any class.

Identify overly defensive code that checks for unrealistic conditions, such as excessive `nil?` checks or redundant type verifications.

Route all analytics events through a single service/helper instead of calling the SDK directly from widgets and blocs.

Generate cache/Redis keys through a single utility with clear namespaces and versioning.

Define shared string literals (route names, keys, claim types) as constants/enums in a single place.

Ensure that multiple loops over the same collection are combined into a single loop to improve efficiency.

Deduplicate near-identical Dockerfiles by sharing a common base stage (multi-stage) and varying only service-specific steps via build args/targets.

Extract reusable SQL fragments/builders for commonly repeated WHERE/ORDER clauses.

Avoid maintaining multiple equivalent validators for the same shape; centralize checks in a single function/schema.

Provide a single updater that applies deltas/patches to messages rather than multiple ad-hoc updaters.

Merge near-duplicate methods into a single parameterized method or strategy.

Replace repeated set/get config calls with data-driven loops or loaders from a single schema/source.