Skip to main content
Glama

deslop-mcp

An MCP (Model Context Protocol) server that detects and removes AI-generated code slop patterns.

Works with Cursor, Claude Desktop, Claude Code, and any MCP-compatible client.

What is "Slop"?

AI-generated code often includes patterns that hurt maintainability:

  • Comment slop: Comments that restate what code does ("This function gets the user")

  • Verbose logging: Entry/exit logs, debug statements left in production

  • Unnecessary error handling: Try-catch that only logs and re-throws

  • Defensive overkill: Redundant null checks in TypeScript

  • Async misuse: async functions with no await

  • Unused imports: Dead code from refactoring

Related MCP server: open-code-review

Installation

Option 1: Clone from GitHub

git clone https://github.com/YOUR_USERNAME/deslop-mcp.git
cd deslop-mcp
npm install
npm run build

Option 2: npm (if published)

npm install -g deslop-mcp

Configuration

For Cursor

Add to your Cursor MCP settings (~/.cursor/mcp.json or via Settings > MCP):

{
  "mcpServers": {
    "deslop": {
      "command": "node",
      "args": ["/path/to/deslop-mcp/dist/index.js"]
    }
  }
}

For Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "deslop": {
      "command": "node",
      "args": ["/path/to/deslop-mcp/dist/index.js"]
    }
  }
}

For Claude Code

Add to your Claude Code MCP settings:

{
  "mcpServers": {
    "deslop": {
      "command": "node",
      "args": ["/path/to/deslop-mcp/dist/index.js"]
    }
  }
}

Tools

deslop_analyze

Analyze code files for slop patterns.

deslop_analyze({ path: "./src" })
deslop_analyze({ path: "./src/utils/api.ts" })

Returns a detailed report with:

  • Issues grouped by category

  • Priority levels (high/medium/low)

  • Line numbers for each issue

  • Auto-fixable indicators

deslop_fix

Automatically fix auto-fixable issues.

deslop_fix({ path: "./src" })
deslop_fix({ path: "./src", dryRun: true })  // Preview without changes

deslop_diff

Analyze only changed files from git.

deslop_diff({})                    // Unstaged changes
deslop_diff({ staged: true })      // Staged changes only

Example Output

# Deslop Analysis Report

## Summary
- 🔴 High Priority: 12 issues
- 🟡 Medium Priority: 5 issues
- 🔵 Low Priority: 2 issues
- 🔧 Auto-fixable: 10 issues

## src/services/userService.ts

### 🔴 Comment Slop (3)

- **Line 45**: Comment restates what code does instead of why
  `// This function gets the user from the database`
  *(auto-fixable)*

- **Line 78**: Commented-out code should be removed
  `// const oldUser = await getOldUser(id);`
  *(auto-fixable)*

### 🔴 Verbose Logging (2)

- **Line 23**: Debug/trace logging should be removed in production
  `console.log("Entering getUserById");`
  *(auto-fixable)*

Supported Languages

  • TypeScript (.ts, .tsx)

  • JavaScript (.js, .jsx)

  • Python (.py)

  • Java (.java)

  • Go (.go)

  • Rust (.rs)

Safety

The tool will never remove:

  • Error logging that captures actual errors

  • Comments explaining business logic or "why"

  • License headers or copyright notices

  • TODO comments with ticket references

License

MIT

Available Tools

3 tools
deslop_analyzeC

Analyze code files for AI-generated slop patterns (verbose comments, unnecessary logging, redundant error handling, etc.)

Inputs: path (required).

deslop_diffC

Analyze only changed files from git diff for slop patterns

Inputs: staged.

deslop_fixC

Automatically fix auto-fixable slop patterns in code files (removes verbose comments, debug logging, etc.)

Inputs: path (required), dryRun.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: deslop_analyze examines all code files for slop patterns, deslop_diff focuses on changed files from git diff, and deslop_fix performs automated fixes. There is no overlap in functionality, making it easy for an agent to select the appropriate tool based on the task.

    Naming Consistency5/5

    All tool names follow a consistent 'deslop_' prefix with a descriptive suffix (analyze, diff, fix), using snake_case uniformly. This predictable pattern enhances readability and reduces confusion for agents.

    Tool Count5/5

    With 3 tools, the server is well-scoped for its purpose of analyzing and fixing AI-generated slop in code. Each tool serves a distinct role in the workflow (analysis, diff analysis, fixing), and there are no extraneous or missing tools for this focused domain.

    Completeness5/5

    The tool set provides complete coverage for the slop analysis domain: deslop_analyze for initial assessment, deslop_diff for incremental changes, and deslop_fix for remediation. This covers the core lifecycle from detection to correction without any apparent gaps.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Provides comprehensive codebase analysis including project structure evaluation, cross-language duplicate detection, microservices validation, and configuration optimization with AI-powered pattern learning that generates actionable improvement reports.
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      AI-powered code review tool that detects AI-generated code defects invisible to traditional linters — hallucinated packages, deprecated APIs, cross-file contradictions, hidden security anti-patterns, and over-engineering. Works as a standalone CLI, GitHub Action, or MCP server. Supports TypeScript, Python, Java, Go, and Kotlin. Free for individuals, no API key required.
      4
      40
      Business Source 1.1
    • A
      license
      A
      quality
      C
      maintenance
      Enables detection and elimination of AI slop in text, providing tools to analyze writing for overused phrases, structural issues, and verbosity, and offers human writing rules tailored to context.
      3
      3
      MIT