Readability & Refactor rules

All exported JS/TS functions, classes, and public members must include JSDoc with a summary and @param/@returns; include @throws when applicable.

Prefer Server Components for pages/layouts and move interactivity to small leaf Client Components. Only add 'use client' where browser APIs or event handlers are strictly necessary.

Ensure that lambda expressions remain short and simple. If a lambda grows too complex, refactor it into a titled method.

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

Use `for` elements inside map literals instead of `Map.fromIterable` to improve readability and allow better compiler optimizations.

Use `is!` instead of `!is` for type checking to prevent confusion and ensure consistent behavior.

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

Check if React children are passed as regular props instead of being nested inside components. Passing them incorrectly can cause conflicts and reduce clarity.

Identify function parameters that are declared but never used within the function body. Remove them to improve clarity and maintainability.

Avoid the !! operator. Prefer safe calls, Elvis (?:), early returns, or explicit exceptions with a clear message.

If the PR is large (many files/lines), split it into logical chunks or provide a clear justification and review guide listing file groups and what to focus on.

Keep UI/controllers thin; move domain logic to services or domain objects.

Calling synchronous methods inside async code can block execution and reduce performance. Use awaitable methods to ensure proper async execution.

All public types and members must have XML documentation comments with <summary>, <param>, <returns> (if non-void), and <exception> when thrown.

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

Ensure that titlespace structures are not overly deep. Favor a flat, organized structure to enhance readability and navigation.

Treat function inputs as immutable; copy before mutation (e.g., dict.copy(), list(x)).

Ensure that large classes with multiple responsibilities are refactored into smaller, more manageable classes.

Identify lambda functions that are too complex. Lambdas should be simple and concise. If a lambda contains multiple expressions, recommend converting it to a titled function for better readability.

Never use a pointer to an interface type. Pass interfaces as values, since an interface already provides reference semantics to the underlying data.

Do not use pointers to slice or map types. Slices and maps are already reference types that point to underlying data, so they can be passed by value and still allow modifications to the contents.

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.

Check if semicolons are used at the end of statements in Python code. Semicolons are unnecessary and may cause readability issues or errors when multiple statements are placed on one line. Recommend using new lines instead.

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