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