Slop Score

A reason to look closer.

Slop Signals

1. 1. Large Volume, Low Signal (High Confidence)

   Flag PRs where:

   • Hundreds or thousands of lines changed with little architectural value.
   • Many files contain repetitive edits.
   • Boilerplate is copied across modules.
   • Most changes are mechanical renames or wrappers.

   Example:

   • 1,200 LOC changed
   • 65 files
   • Only 2 meaningful business logic changes

2. 2. Generic Naming

   Detect identifiers like:

   • helper
   • util
   • processData
   • handleRequest
   • temp
   • newFunction
   • Manager2
   • ServiceImpl

   Also detect:

   • Inconsistent naming conventions
   • Different naming styles within the same PR

3. 3. Excessive Comments

   AI often explains obvious code.

   Example:

   In Java

   // Increment the counter
   counter++;
   // Return the result
   return result;

   or in Python

   # Loop through the list
   for item in items:

4. 4. Dead or Unused Code

   Look for:

   • Unused helper methods
   • Unreachable code
   • Unused imports
   • Never-called functions
   • Unused variables

   AI frequently generates "just in case" code.

5. 5. Duplicate Logic

   Compare against the repository:

   • Existing implementations
   • Similar algorithms
   • Nearly identical methods

   Flag:

   Existing implementation found in UserService.java.

   instead of approving duplicated code.

6. 6. Hallucinated APIs

   Examples:

   userRepository.findLatestUser()

   when no such method exists.

   Or

   response.getStatusText()

   when the SDK doesn't provide it.

   These are classic LLM hallucinations.

7. 7. Overly Defensive Code

   Examples:

   if x is not None:
       if len(x) > 0:
           if isinstance(x, list):

   when

   if x:

   would suffice.

8. 8. Excessive Nesting

   AI often produces:

   if (...)
       if (...)
           if (...)
               if (...)

   instead of early returns.

   Measure:

   • Cyclomatic complexity
   • Nesting depth
   • Cognitive complexity

9. 9. Inconsistent Style

   Detect:

   • Mixed quote styles
   • Different indentation
   • Variable naming changes
   • Mixed error handling patterns
   • Different logging frameworks

   Often indicates code assembled from multiple AI generations.

10. 10. Missing Tests

    Large behavioral changes with:

    • No new tests
    • No updated tests
    • Only snapshot changes

    High-risk indicator.

11. 11. Superficial Error Handling

    Patterns like:

    catch(Exception e) { }

    or

    except:
        pass

    or

    catch(e) {
        console.log(e)
    }

    These often appear in AI-generated code.

12. 12. Overengineered Solutions

    Examples:

    • Factory pattern for one implementation
    • Three interfaces with one class
    • Generic abstractions that are never reused

    AI tends to overgeneralize.

13. 13. Low Semantic Density

    Examples:

    def executeProcessingPipeline():
        performProcessing()

    where methods add little value beyond wrapping another call.

    Measure:

    • Wrapper methods
    • Pass-through abstractions
    • Thin delegation chains

14. 14. Documentation Mismatch

    Detect when:

    • Code changes
    • README unchanged
    • API docs unchanged
    • Comments describe previous behavior

15. 15. Suspicious Commit Patterns

    Examples:

    • One enormous AI-generated commit
    • Generic commit messages:
      • "Update"
      • "Fix issue"
      • "Refactor"
    • No incremental history