---

name: ai-slop-cleanup description: Identify and clean up AI-generated code patterns including excessive comments, magic numbers, duplicate code, and dead code. Use when code contains quality issues commonly introduced during AI-assisted development. Compatible with Claude Code, Cursor, Windsurf, Zed, VS Code with Copilot, and other Agent Skills compatible editors. invocation: automatic: true triggers: - "ai.*slop|slop.*cleanup|clean.*slop" - "excessive.*comment|remove.*comment" - "magic.*number|hardcoded.*value" - "duplicate.*code|copy.*paste" - "placeholder|todo.*implement|fixme" - "console.log|debug.*statement" - "code.*quality.*check|review.*quality" - "refactor.*ai.*code|clean.*generated" examples:

• "Check this file for AI slop"
• "Clean up excessive comments and placeholders"
• "Review code quality and remove AI-generated patterns"
• "Find and fix magic numbers in this codebase"
• "Remove console.log statements from production code"
• "Identify duplicate code patterns" outputStyle: comprehensive

---

AI Slop Cleanup

This skill helps identify and remove AI-generated code patterns that degrade code quality. AI often introduces specific anti-patterns during code generation.

Compatibility

This skill follows the Agent Skills open standard and works across multiple AI coding assistants:

• Claude Code (CLI & Desktop)
• Cursor - AI-native IDE
• Windsurf - Codeium's AI IDE
• Zed - High-performance code editor
• VS Code + GitHub Copilot - With Agent Skills support
• Continue.dev - VS Code/JetBrains extension
• OpenCode - Terminal-based assistant
• And other tools supporting the Agent Skills format

Write once, use everywhere - the same skill file works across all compatible environments.

When to Use

Activate this skill when you notice:

• Code contains excessive comments explaining obvious operations
• Magic numbers and hardcoded values without context
• Duplicate code blocks across multiple files
• Placeholder comments like // TODO: add logic
• Variations of the same validation or error handling patterns
• Console.log statements left in production code
• Nested ternary operators that are hard to read
• Redundant type checks in typed code
• Generic catch blocks that swallow errors

What It Does

Analysis Phase

1. Scan files for AI slop patterns:

   A. Excessive Comments

   • Look for comments that explain what code literally does
   • Find step-by-step breakdowns of simple operations
   • Identify "teleprompter" style annotations

   B. Magic Numbers

   • Find unexplained numeric constants in calculations
   • Locate hardcoded timeout values without documentation
   • Spot magic strings and URLs added by automation

   C. Duplication

   • Detect near-identical functions across multiple files
   • Recognize repeated validation logic patterns
   • Identify standard error handling that's been copy-pasted

   D. Placeholder Code

   • Find // TODO, // FIXME, // Add comments
   • Locate skeleton implementations with minimal bodies
   • Spot arrays/objects with placeholder values

   E. Debugging Leftovers

   • Detect console.log statements in production code
   • Find strategic logging for debugging
   • Identify step-by-step execution logging

   F. Code Structure Issues

   • Spot nested ternary operators (3+ levels)
   • Find redundant null/undefined checks
   • Detect generic catch blocks that swallow errors
   • Identify inconsistent abstraction levels

2. Calculate severity score:

   • Critical (100 pts): Security issues, silent failures
   • High (50 pts): Placeholders, magic numbers, duplication
   • Medium (20 pts): Excessive comments, console.log, nested ternaries
   • Low (5 pts): Style issues, redundant checks

3. Generate comprehensive report:

   • Overall slop grade (A-F)
   • Pattern breakdown with counts
   • File-by-file findings
   • Fix suggestions with before/after examples

Fix Phase

Apply prioritized fixes based on impact:

Critical Priority (immediate):

• Remove commented-out code with secrets or sensitive data
• Delete unused imports that could cause conflicts
• Fix silent failures that hide errors
• Remove insecure hardcoded credentials

High Priority (reduces complexity):

• Extract duplicate code into reusable functions
• Replace magic numbers with named constants
• Implement placeholder logic with actual implementations
• Fix generic catch blocks with specific error handling

Medium Priority (improves readability):

• Remove self-explanatory comments
• Delete // TODO: add logic with no follow-up
• Clean up console.log debugging statements
• Simplify nested ternary operators

Low Priority (style preferences):

• Remove excessive blank lines
• Simplify overly verbose variable names
• Remove redundant type checks in typed code

Approach

Step 1: Detect Patterns

Option A: Use automated detection scripts

# Run the shell script
./scripts/detect-slop.sh src/

# Or use the Node.js version
node scripts/detect-slop.js src/

# With JSON output for further processing
node scripts/detect-slop.js src/ --json > slop-report.json

Option B: Manual grep-based detection

# Find excessive comments
grep -rn "// [A-Z]" source/ | grep -v "^//" | wc -l

# Find TODO placeholders
grep -rn "TODO.*implement\|TODO.*add\|TODO.*handle" src/

# Find magic numbers (potential candidates)
grep -rn "=== [0-9][0-9]*\|length > [0-9]\|timeout.*[0-9]" src/

# Find console.log debugging
grep -rn "console.log" src/ | grep -v "test\|spec"

# Find nested ternaries
grep -rn "?.*?.*?:" src/

Step 2: Categorize Issues

For each pattern found:

1. Count occurrences
2. Identify affected files
3. Assess severity (Critical/High/Medium/Low)
4. Determine whether immediate action is needed

The automated script will:

• Calculate a weighted score based on severity
• Assign an overall grade (A-F)
• Group findings by pattern type
• Show the most problematic files first

Step 3: Generate Fix Suggestions

Use the fix suggestion generator:

# Get fix suggestions for a specific file
node scripts/fix-suggestions.js src/utils/validation.js

# Save suggestions to a report
node scripts/fix-suggestions.js src/utils/validation.js fix-report.json

This will output:

• Line-by-line fix suggestions
• Before/after code examples
• Diff output showing changes
• Pattern-specific recommendations

Step 4: Apply Fixes

Option A: Manual application

• Read each problematic file
• Apply targeted fixes using the suggestions
• Use replace_in_file for precise modifications
• Keep related changes together
• Maintain code functionality

Option B: Semi-automated fixes

// Some patterns can be auto-fixed:
// - Remove console.log statements
// - Remove blank TODO comments
// - Simplify redundant null checks

Example transformation:

// BEFORE: AI-generated placeholder
function validatePassword(password) {
  // TODO: implement validation
  // Validate password complexity
  // Check length
}

// AFTER: Proper implementation
function validatePassword(password) {
  if (password.length < 8) {
    throw new Error('Password must be at least 8 characters');
  }
  if (!/[A-Z]/.test(password)) {
    throw new Error('Password must contain uppercase letters');
  }
  // ... additional checks as appropriate
}

Step 5: Verify

After changes:

1. Run any available test suite
2. Verify the code still compiles
3. Check for unintended side effects
4. Ensure no functionality was accidentally removed
5. Re-run detection to confirm improvements

Step 6: Track Progress (Optional)

# Record metrics after cleanup
node scripts/metrics-tracker.js record slop-report.json

# Generate HTML report with trends
node scripts/metrics-tracker.js report

# View 30-day trend
node scripts/metrics-tracker.js trend

Success Criteria

The skill succeeds when:

• All critical issues (hidden secrets, silent failures) are resolved
• No placeholder TODO comments remain with unclear intent
• Magic values have been explained or converted to constants
• Duplicate code has been extracted into shared functions
• Console.log debugging statements are removed from production
• Code complexity is reduced through refactoring
• Overall slop grade has improved (A-D is acceptable)
• Report is generated showing before/after metrics

Reporting

After cleanup, provide a clear summary:

AI Slop Cleanup Report
======================

Summary:
- Initial Score: 350 (Grade: D)
- Final Score: 85 (Grade: B)
- Issues Resolved: 23 of 28
- Files Modified: 5

Patterns Found and Fixed:
✅ Magic Numbers: 8 instances → Extracted to constants
✅ Console.log Debugging: 12 instances → Removed
✅ Teleprompter Comments: 15 blocks → Cleaned up
✅ Nested Ternaries: 3 instances → Refactored
✅ Redundant Checks: 6 instances → Simplified
⚠️  Placeholder TODOs: 4 instances → Need implementation
⚠️  Duplicate Code: 2 instances → Need extraction

Changes Applied:
1. Created constants file (src/constants/validation.js)
2. Removed 125 lines of excessive comments
3. Extracted duplicate validation into shared function
4. Refactored nested ternaries to readable code
5. Removed debugging console.log statements

Files Modified:
- src/utils/auth.js (refactored)
- src/api/users.js (cleaned up)
- src/validation/common.js (new)
- src/constants/index.js (new)
- src/components/UserForm.tsx (simplified)

Verification:
✅ All tests passing
✅ No regressions introduced
✅ Code complexity reduced by ~35%
✅ Type checking still passes

Tools Used

Primary Detection Tools:

• detect-slop.sh: Bash script for comprehensive pattern detection
• detect-slop.js: Node.js script with JSON output support
• fix-suggestions.js: Generate before/after comparisons and diffs
• metrics-tracker.js: Track quality improvements over time

Supporting Tools:

• Read: Analyze source files for patterns
• Edit/Replace in File: Apply targeted fixes
• Grep: Pattern searching across codebase
• Glob: File discovery and pattern matching
• Bash: Execute detection scripts and commands

Best Practices

1. Preserve intent: Only remove what AI slop adds, keep important context
2. Keep explanations: Security-related comments explaining WHY are valuable
3. Document changes: Note intentional simplifications in git commits
4. Maintain compatibility: Ensure fixes don't break existing interfaces

Integration

This skill should work independently but can complement:

• code-review: Slop cleanup as part of code quality review
• test-fixing: Remove TODOs by implementing actual tests
• legal: Remove code templates/boilerplate as appropriate

CI/CD Integration

GitHub Actions (.github/workflows/ai-slop-check.yml):

• Automatically runs on push and pull requests
• Comments on PRs with findings
• Fails build if threshold exceeded

GitLab CI (gitlab-ci.yml):

• Runs on merge requests to main/develop
• Generates HTML reports
• Can be configured to allow failures

Pre-commit Hooks (.husky/pre-commit):

• Scans only staged files
• Fast feedback before commit
• Can be bypassed if needed

Configuration

Customize behavior via ai-slop.config.json:

• Enable/disable specific patterns
• Set severity thresholds
• Configure ignore patterns
• Control output format
• Enable auto-fix options

References

For detailed AI slop patterns and detection strategies, see:

• references/ai-slop-patterns.md - Comprehensive pattern database with 16+ patterns
• references/language-specific-patterns.md - Language-specific patterns for TypeScript, Python, React, Rust, Go, Java

Notes

• Always verify that TODO comments are intentional before removing them
• Security-related explanations (explained WHY) should be preserved
• Some AI slop may be intentional documentation for future context
• Always test after cleanup to ensure no functionality is broken
• Use configuration to exclude files/patterns as needed
• Track metrics over time to see improvement trends
• Integrate into CI/CD for continuous quality monitoring

Version History

v2.0.0 (Current):

• Added 8 new detection patterns (16 total)
• Added automated detection scripts (bash + Node.js)
• Added fix suggestion generator with diff output
• Added metrics tracking and HTML reports
• Added language-specific pattern expansions
• Added CI/CD integration examples
• Added pre-commit hook support
• Added configuration system
• Added severity scoring algorithm

v1.0.0:

• Initial release with 8 core patterns
• Manual detection commands
• Basic fix recommendations