/slop

name: slop
description: "Remove AI-generated code slop from git diffs to maintain code quality"
license: MIT
compatibility: cline, claude, opencode, amp, codex, gemini, cursor, pi
hint: Use when cleaning up AI-generated code slop in git diffs
user-invocable: true
metadata:
  audience: all
  workflow: code-quality

Remove AI Code Slop

Check the diff against a branch and remove all AI-generated slop introduced in this branch. Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality.

Usage

`/slop [branch-name]`

• If no branch is provided, compare against main: `/slop main`

What is AI Code Slop?

This includes:

• Extra comments that a human wouldn't add or is inconsistent with the rest of the file
• Extra defensive checks or try/catch blocks that are abnormal for that area of the codebase
• Casts to `any` to get around type issues
• Any other style that is inconsistent with the file

Core Principles

1. Preserve Functionality

Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.

2. Apply Project Standards

Follow the established coding standards from `@CLAUDE.md` or conventions:

• Use proper import sorting and file organization
• Follow language-specific patterns (ES modules, proper TypeScript types, etc.)
• Maintain consistent naming conventions
• Use proper error handling patterns

3. Enhance Clarity

Simplify code structure by:

• Reducing unnecessary complexity and nesting
• Eliminating redundant code and abstractions
• Improving readability through clear variable and function names
• Consolidating related logic
• Removing unnecessary comments that describe obvious code
• **IMPORTANT**: Use switch statements or if/else chains over nested ternary operators
• Choose clarity over brevity - explicit code is often better than overly compact code

4. Maintain Balance

Preserve necessary complexity — over-simplification can:

• Reduce code clarity or maintainability
• Create overly clever solutions that are hard to understand
• Combine too many concerns into single functions
• Remove helpful abstractions that improve code organization
• Prioritize "fewer lines" over readability

Process

1. Get the diff

# Compare against main branch
git diff main...HEAD --stat

# Or against specific branch
git diff $1 --stat

2. Review each changed file

For each changed file:

• Read the current content
• Compare with original (before changes)
• Identify AI-generated slop patterns
• Check for opportunities to improve elegance and consistency

3. Remove slop and refine

• Remove unnecessary comments
• Simplify overly defensive code
• Remove `any` casts where possible
• Restore natural code style
• Apply project-specific best practices
• Ensure all functionality remains unchanged

4. Verify

# Show remaining changes
git diff --stat

# Check tests still pass
npm test

Common Slop Patterns

1. **Over-commenting**: Comments explaining obvious code 2. **Verbose error handling**: Try/catch blocks where not needed 3. **Unnecessary type casts**: `x as any` to bypass TypeScript 4. **Defensive programming**: Checks for already-validated inputs 5. **Redundant validation**: Duplicate null/undefined checks 6. **Nested ternaries**: Complex nested ternary operators 7. **Overly compact code**: Dense one-liners that sacrifice readability

Refinement Guidelines

When refining code:

1. **Identify the modified sections** - Only refine code that changed in the diff 2. **Analyze for improvement opportunities** - Look for ways to enhance elegance and consistency 3. **Apply project standards** - Follow established conventions and patterns 4. **Preserve functionality** - Ensure behavior remains unchanged 5. **Verify improvements** - The refined code should be simpler and more maintainable 6. **Document significant changes** - Only document changes that affect understanding

Code Style Preferences

• Prefer explicit over compact - readable code beats clever code
• Use descriptive names - clarity over brevity
• Flatten deep nesting with early returns and guard clauses
• Remove redundant code - eliminate duplicates
• Use language-appropriate patterns - follow idiomatic practices