Skip to main content
Glama
JoodasCode

SlopWatch MCP Server

by JoodasCode
OverviewSchemaRelated ServersScoreDiscussions
JavaScript

🎯 SlopWatch - AI Accountability MCP Server

Stop AI from lying about what it implemented! Track what AI claims vs what it actually does.

NPM Version NPM Downloads NPM Downloads Weekly Available on Smithery.ai Cursor MCP License: MIT

🚀 What's New in v2.7.0

✨ Ultra-Minimal Responses - 90% less verbose output
🔄 Combined Tool - Single call instead of 2 separate tools
⚡ Seamless Workflow - Perfect for AI pair programming
🎯 Cursor MCP Compatible - Works seamlessly with Cursor IDE

Related MCP server: casuallayer-mcp

🤔 Why SlopWatch?

Ever had AI say "I've added error handling to your function" but it actually didn't? Or claim it "implemented user authentication" when it just added a comment?

SlopWatch catches AI lies in real-time.

⚡ Quick Start

🎯 Option 1: Smithery (Easiest - 1 click install)

  1. Visit smithery.ai/server/@JoodasCode/slopwatch

  2. Click "Install to Cursor" or "Install to Claude"

  3. Done! ✨

Smithery handles hosting, authentication, and updates automatically

🔧 Option 2: NPM Direct (Manual Setup)

For Cursor IDE:

{
  "mcpServers": {
    "slopwatch": {
      "command": "npx",
      "args": ["slopwatch-mcp-server"]
    }
  }
}

Manual Cursor Setup:

  1. Open Cursor Settings (Cmd+Shift+J on Mac, Ctrl+Shift+J on Windows)

  2. Go to Features → Model Context Protocol

  3. Click "Add New MCP Server"

  4. Configure:

    • Name: SlopWatch

    • Type: stdio

    • Command: npx slopwatch-mcp-server

For Claude Desktop: Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "slopwatch": {
      "command": "npx",
      "args": ["slopwatch-mcp-server"]
    }
  }
}

Global NPM Install:

npm install -g slopwatch-mcp-server

🎮 How to Use

Method 1: Combined Tool (Recommended ⭐)

Perfect for when AI implements something and you want to verify it:

// AI implements code, then verifies in ONE call:
slopwatch_claim_and_verify({
  claim: "Add input validation to calculateSum function",
  originalFileContents: {
    "utils/math.js": "function calculateSum(a, b) { return a + b; }"
  },
  updatedFileContents: {
    "utils/math.js": "function calculateSum(a, b) {\n  if (typeof a !== 'number' || typeof b !== 'number') {\n    throw new Error('Invalid input');\n  }\n  return a + b;\n}"
  }
});

// Response: "✅ PASSED (87%)"

Method 2: Traditional 2-Step Process

For when you want to claim before implementing:

// Step 1: Register claim
slopwatch_claim({
  claim: "Add error handling to user login",
  fileContents: {
    "auth.js": "function login(user) { return authenticate(user); }"
  }
});
// Response: "Claim ID: abc123"

// Step 2: Verify after implementation
slopwatch_verify({
  claimId: "abc123",
  updatedFileContents: {
    "auth.js": "function login(user) {\n  try {\n    return authenticate(user);\n  } catch (error) {\n    throw new Error('Login failed');\n  }\n}"
  }
});
// Response: "✅ PASSED (92%)"

🛠️ Available Tools

Tool

Description

Response

slopwatch_claim_and_verify

⭐ Recommended - Claim and verify in one call

✅ PASSED (87%)

slopwatch_status

Get your accountability stats

Accuracy: 95% (19/20)

slopwatch_setup_rules

Generate .cursorrules for automatic enforcement

Minimal rules content

🎯 Cursor IDE Integration

SlopWatch is designed specifically for Cursor IDE and AI pair programming:

Automatic Detection

  • Detects when AI claims to implement features

  • Automatically suggests verification

  • Integrates seamlessly with Cursor's Composer

Smart Workflow

1. AI: "I'll add error handling to your function"
2. SlopWatch: Automatically tracks the claim
3. AI: Implements the code
4. SlopWatch: Verifies implementation matches claim
5. Result: ✅ PASSED (92%) or ❌ FAILED (23%)

Perfect for:

  • Code reviews - Verify AI actually implemented what it claimed

  • Pair programming - Real-time accountability during development

  • Learning - Understand what AI actually does vs what it says

  • Quality assurance - Catch implementation gaps before they become bugs

💡 Real-World Examples

Example 1: API Endpoint Enhancement

// AI says: "I'll add rate limiting to your API endpoint"

slopwatch_claim_and_verify({
  claim: "Add rate limiting middleware to /api/users endpoint",
  originalFileContents: {
    "routes/users.js": "app.get('/api/users', (req, res) => { ... })"
  },
  updatedFileContents: {
    "routes/users.js": "const rateLimit = require('express-rate-limit');\nconst limiter = rateLimit({ windowMs: 15*60*1000, max: 100 });\napp.get('/api/users', limiter, (req, res) => { ... })"
  }
});
// Result: ✅ PASSED (94%)

Example 2: React Component Update

// AI claims: "Added responsive design with CSS Grid"

slopwatch_claim_and_verify({
  claim: "Make UserCard component responsive using CSS Grid",
  originalFileContents: {
    "components/UserCard.jsx": "const UserCard = () => <div className=\"user-card\">...</div>"
  },
  updatedFileContents: {
    "components/UserCard.jsx": "const UserCard = () => <div className=\"user-card grid-responsive\">...</div>",
    "styles/UserCard.css": ".grid-responsive { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 1rem; }"
  }
});
// Result: ✅ PASSED (89%)

📊 Accountability Stats

Track your AI's honesty over time:

slopwatch_status();
// Returns: "Accuracy: 95% (19/20)"

  • Accuracy Score: Percentage of claims that were actually implemented

  • Claim Count: Total number of implementation claims tracked

  • Success Rate: How often AI delivers what it promises

🔧 Advanced Configuration

Auto-Enforcement with .cursorrules

Generate automatic accountability rules:

slopwatch_setup_rules();

This creates a .cursorrules file that automatically enforces SlopWatch verification for all AI implementations.

Custom Verification

SlopWatch analyzes:

  • File changes - Did the files actually get modified?

  • Code content - Does the new code match the claim?

  • Implementation patterns - Are the right patterns/libraries used?

  • Keyword matching - Does the code contain relevant keywords?

🚀 Why Choose SlopWatch?

For Developers:

  • Catch AI lies before they become bugs

  • Learn faster by seeing what AI actually does

  • Improve code quality through automatic verification

  • Save time with streamlined accountability

For Teams:

  • Standardize AI interactions across team members

  • Track AI reliability over time

  • Reduce debugging from AI implementation gaps

  • Build trust in AI-assisted development

For Cursor Users:

  • Native integration with Cursor's Composer

  • Seamless workflow - no context switching

  • Real-time feedback during development

  • Ultra-minimal responses - no verbose output

🎯 Getting Started with Cursor

  1. Install SlopWatch using one of the methods above

  2. Open Cursor and start a new chat with Composer

  3. Ask AI to implement something: "Add input validation to my function"

  4. Watch SlopWatch work: It automatically tracks and verifies the claim

  5. Get instant feedback: ✅ PASSED (87%) or ❌ FAILED (23%)

🔍 Troubleshooting

Common Issues:

  • Tools not showing: Restart Cursor after installation

  • Verification failed: Check if files were actually modified

  • NPM errors: Try npm cache clean --force and reinstall

Debug Mode:

Enable detailed logging by setting DEBUG=true in your environment.

📈 Roadmap

  • Visual dashboard for accountability metrics

  • Integration with Git for commit verification

  • Team analytics for multi-developer projects

  • Custom verification rules for specific frameworks

  • IDE extensions for other editors

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

📝 License

MIT License - see LICENSE for details.

🌟 Support

Made with ❤️ for the Cursor community

Stop AI from lying about what it implemented. Start using SlopWatch today!

Available Tools

3 tools
slopwatch_claim_and_verifyC

Register claim and verify implementation in one call - reduces from 2 tool calls to 1

ParametersJSON Schema
NameRequiredDescriptionDefault
claimYesWhat you implemented
originalFileContentsYesOriginal content of files before implementation (filename -> content)
updatedFileContentsYesUpdated content of files after implementation (filename -> content)

TDQS

C2.7/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool performs 'register claim and verify implementation', which suggests a mutation operation, but doesn't disclose any behavioral traits such as side effects, error handling, permissions required, or what 'verification' entails. The description is too brief to provide meaningful context beyond the basic operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise with only one sentence that directly states the tool's purpose and benefit. It is front-loaded with no wasted words, making it easy to parse quickly. Every part of the sentence earns its place by conveying key information efficiently.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity implied by a combined 'register and verify' operation with 3 parameters (including nested objects) and no annotations or output schema, the description is insufficient. It lacks details on what the tool actually does, how verification works, what happens on success/failure, or any domain context. The description does not compensate for the missing structured data, making it incomplete for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with clear descriptions for all 3 parameters (claim, originalFileContents, updatedFileContents). The description adds no additional parameter semantics beyond what the schema provides, such as format details or examples. Given the high schema coverage, the baseline score of 3 is appropriate as the schema handles the documentation adequately.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool 'registers claim and verifies implementation in one call', which indicates a combined operation. However, it's vague about what 'claim' and 'verification' specifically entail, and it doesn't clearly distinguish this tool from its siblings (slopwatch_setup_rules, slopwatch_status) beyond mentioning it reduces from 2 tool calls to 1. The purpose is understandable but lacks specificity about the resource or domain context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions that this tool 'reduces from 2 tool calls to 1', implying it should be used as a combined alternative to separate operations. However, it doesn't specify what those 2 tool calls are, when to prefer this over them, or any prerequisites. No explicit when/when-not guidance or alternatives are provided, leaving usage context unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

slopwatch_setup_rulesC

Generate .cursorrules file with AI accountability enforcement

ParametersJSON Schema
NameRequiredDescriptionDefault
project_pathYesPath to project directory where .cursorrules should be created
overwriteNoWhether to overwrite existing .cursorrules file

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions the tool 'generates' a file, implying a write operation, but doesn't specify permissions needed, side effects, or what 'AI accountability enforcement' entails. The description lacks details on file format, success/failure conditions, or any behavioral traits beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to understand at a glance. Every part of the sentence contributes to clarifying the tool's function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of generating a configuration file with 'AI accountability enforcement' and no annotations or output schema, the description is incomplete. It doesn't explain what the generated file contains, how it enforces accountability, or what the tool returns. This leaves significant gaps for an agent to understand the tool's full context and behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('project_path' and 'overwrite') thoroughly. The description adds no additional meaning or context about parameters beyond what's in the schema, such as path format examples or implications of overwriting. This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate .cursorrules file with AI accountability enforcement'. It specifies the verb ('Generate'), resource ('.cursorrules file'), and purpose ('AI accountability enforcement'), making the function unambiguous. However, it doesn't differentiate from sibling tools like 'slopwatch_claim_and_verify' or 'slopwatch_status', which prevents a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, appropriate contexts, or comparisons with sibling tools. The only implied usage is when needing to create a .cursorrules file, but this is too vague for effective tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

slopwatch_statusB

Get current slop score and statistics

ParametersJSON Schema
NameRequiredDescriptionDefault
random_stringYesDummy parameter for no-parameter tools

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get'), but doesn't specify whether this requires authentication, has rate limits, returns real-time or cached data, or what format the statistics include. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose ('Get current slop score and statistics'), making it easy to parse quickly. Every word earns its place in this concise formulation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete for a tool that presumably returns data. It doesn't explain what 'slop score' means, what statistics are included, or the format of the response. For a read operation with no structured output documentation, the description should provide more context to be fully helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, documenting the single parameter as a 'Dummy parameter for no-parameter tools.' The description doesn't add any parameter details beyond this, but since the schema fully covers the parameter and it's a dummy placeholder, the baseline is high. A score of 4 reflects that the description doesn't detract from the schema's clarity for this simple case.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('current slop score and statistics'), making it immediately understandable. However, it doesn't explicitly differentiate this read-only status tool from its sibling tools (slopwatch_claim_and_verify and slopwatch_setup_rules), which appear to involve write operations, so it falls short of a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings or in what context. It lacks any mention of prerequisites, alternatives, or exclusions, leaving the agent to infer usage based on tool names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: one handles claim registration and verification, another generates configuration files, and the third retrieves status metrics. The descriptions make it easy to differentiate their functions, eliminating any risk of misselection.

Naming Consistency5/5

All tool names follow a consistent 'slopwatch_verb_noun' pattern (e.g., slopwatch_claim_and_verify, slopwatch_setup_rules, slopwatch_status). This uniformity makes the set predictable and easy to navigate, with no deviations in style or structure.

Tool Count4/5

With 3 tools, the count is slightly low but reasonable for a server focused on AI accountability and slop scoring. Each tool serves a distinct, essential function, though the scope might feel thin if more operations are expected in this domain.

Completeness4/5

The tools cover core workflows: setup (rules generation), claim handling (registration and verification), and monitoring (status retrieval). Minor gaps might exist, such as tools for updating rules or detailed analytics, but the surface supports basic operations without dead ends.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • sigmodx-mcp

    Sigmodx
    A
    license
    A
    quality
    D
    maintenance
    Audit infrastructure for AI agents to log consequential decisions (invoice, GL, anomaly) and verify attestations via MCP tools.
    6
    MIT

  • casuallayer-mcp

    smq9sn5jck-coder
    A
    license
    Not graded
    quality
    C
    maintenance
    Deterministic AI liability attribution engine. Scores fault across AI supply-chain participants (deployer, developer, vendor) with tamper-evident certificates and weekly cryptographic anchoring.’
    56
    2
    Apache 2.0

  • Warranted

    yqi96
    A
    license
    Not graded
    quality
    A
    maintenance
    Makes AI research agents accountable by giving every conclusion a traceable argument graph. Provides a persistent argument graph where claims require grounds and warrants for auditable, verifiable reasoning.
    2
    MIT

  • mcp-server-decisions

    Roberton003
    A
    license
    A
    quality
    A
    maintenance
    Tracks architectural decisions with testable predictions, outcome validation, and in-band feedback nudges to close decision loops for AI agents and teams.
    4
    MIT

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/JoodasCode/SlopWatch'

If you have feedback or need assistance with the MCP directory API, please join our Discord server