deslop

Detect and remove AI-generated code patterns (slop) from your branches.

AI coding assistants often introduce patterns that experienced developers recognize immediately: obvious comments, excessive try-catch blocks, verbose variable names, and defensive programming overkill. This tool scans your git diffs and flags these patterns before they accumulate into technical debt.

Installation

npm install -g deslop

Or use directly with npx:

npx deslop

Quick Start

# Scan current branch against main
deslop

# Scan against a different base branch
deslop -b develop

# Get just the slop score
deslop score

# See all patterns including low severity
deslop -v

# Output as JSON for CI integration
deslop -j

What It Detects

High Severity

• Debug console.log statements left in code
• Function entry/exit logging patterns

Medium Severity

• Generic TODO placeholders without context
• Triple null/undefined checks
• Empty catch blocks that only log errors
• Excessive function entry/exit logging

Low Severity

• Verbose obvious comments ("Initialize the variable")
• Section divider comments
• Redundant return undefined
• Explicit boolean comparisons (=== true)
• Unnecessary try-catch wrappers
• Promise.all with single promise

Run deslop patterns to see all detection rules.

Commands

| Command | Description | |---------|-------------| | deslop or deslop scan | Scan changed files for slop patterns | | deslop patterns | List all detection patterns | | deslop score | Show slop score only (0-100) |

Options

| Option | Description | |--------|-------------| | -b, --base <branch> | Base branch to compare against (default: main) | | -a, --all | Scan all lines, not just diff additions | | -j, --json | Output as JSON | | -v, --verbose | Show all matches including low severity | | -q, --quiet | Only show summary |

Slop Score

The slop score ranges from 0 to 100:

• 0-19: Clean code
• 20-49: Some cleanup needed
• 50+: Significant slop detected

The score weights issues by severity:

• High severity: 10 points
• Medium severity: 5 points
• Low severity: 1 point

Normalized per analyzed file to prevent larger PRs from scoring worse.

CI Integration

Add to your CI pipeline to catch slop before merge:

# GitHub Actions example
- name: Check for AI slop
  run: npx deslop --json > slop-report.json

- name: Fail if high severity
  run: |
    if [ $(cat slop-report.json | jq '.bySeverity.high') -gt 0 ]; then
      echo "High severity slop detected"
      exit 1
    fi

The CLI exits with code 1 if high severity issues are found.

Programmatic Usage

import { analyzeChanges, calculateSlopScore } from 'deslop';

const results = analyzeChanges({
  baseBranch: 'main',
  diffOnly: true
});

console.log(`Slop score: ${calculateSlopScore(results)}`);
console.log(`High severity: ${results.bySeverity.high}`);

for (const file of results.files) {
  for (const match of file.matches) {
    console.log(`${file.filePath}:${match.lineNumber} - ${match.name}`);
  }
}

Patterns Reference

Verbose Obvious Comments

AI often adds comments that state the obvious:

// Bad (AI slop)
// Initialize the result variable
const result = [];

// Good (human style)
const result = [];

Triple Null Checks

AI tends to be overly defensive:

// Bad (AI slop)
if (value !== null && value !== undefined && value !== '') {
  // ...
}

// Good (human style)
if (value) {
  // ...
}

Debug Logging

AI frequently leaves debug statements:

// Bad (AI slop)
console.log('DEBUG: entering function');
console.log('TEMP: value is', value);

// Good (human style)
// No debug logs in production code

Empty Catch Blocks

AI wraps everything in try-catch:

// Bad (AI slop)
try {
  const data = JSON.parse(str);
} catch (error) {
  console.error('Error parsing JSON:', error);
}

// Good (human style - if you need try-catch)
try {
  const data = JSON.parse(str);
} catch (error) {
  throw new ParseError(`Invalid JSON: ${error.message}`);
}

Why "Slop"?

The term "slop" emerged in developer communities to describe AI-generated code that technically works but has telltale signs of non-human origin: over-engineered, overly defensive, excessively commented, and stylistically inconsistent with human-written code.

Slop isn't necessarily buggy - it's just... sloppy. It clutters codebases, obscures intent, and creates maintenance burden. This tool helps you catch it early.

Contributing

Found a slop pattern that should be detected? Open an issue or PR with:

1. Example of the slop pattern
2. Why it's typically AI-generated
3. Suggested regex or detection logic

License

MIT