Remove AI Code Slop

Usage

/slop [branch-name]

• If no branch is provided, compare against main:

  /slop main

What is AI Code Slop?

• 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

2. Apply Project Standards

• 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

• 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: Avoid nested ternary operators - prefer switch statements or if/else chains
• Choose clarity over brevity - explicit code is often better than overly compact code

4. Maintain Balance

• 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

• 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

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
• Avoid deep nesting - flatten structure when possible
• Remove redundant code - eliminate duplicates
• Use language-appropriate patterns - follow idiomatic practices