The Clean Code guardrail for the Agentic era. Removes AI slop and enforces architectural boundaries via MCP for Cursor and Claude Code.
Embrace the full potential of vibe-coding without sacrificing quality. Add Deslop to your CI and stop the AI slop tech-debt via advanced static analysis.
Deslop bridges the gap between high-speed AI code generation and senior-level architectural standards.
Enforces dependency boundaries and bans problematic imports, function calls, and more. Define your own rules or start from vetted Clean Code templates.
A high-speed Haskell engine enforces them algorithmically with correctness guarantees.
rules:
- id: no-react-in-core
forbidden:
- import: react
transitive: trueExpose tools, context, and prompts to your AI agent through a local MCP server—so generated code stays aligned with your rulebook.
When the model drifts, the Deslop GitHub Action enforces the same rules in CI.
Local MCP server
Tools, context, and prompts wired into your agent's loop.
GitHub Action
Hard enforcement on every pull request—same rules as local.
Goes beyond Biome and ESLint with project-wide, AST-aware checks and fixes.
For example, the Relative Import Fixer replaces brittle ../../ paths in one pass—keep your existing linters and add Deslop as an extra quality gate.
import { User } from '../../../../types';import { User } from '@/types';Deslop lives where you code. Whether it's real-time feedback in your editor or automated gatekeeping in your CI.
Native integration with Cursor and Claude Code for real-time sanitization.
Deslop GitHub Action for automated PR gatekeeping and slop detection.
> deslop --check
deslop 0.4.10 · check · workspace default
Deslopping project: .
847 files in scope · acme-dashboard
RuleBook loaded · 58 rules
Imports & dependency boundaries checked
0 violations · 0 warnings
Success: No problems found.
Finished in 50.89ms
Per-user pricing for local tooling and CI. No hidden tiers—what you see is what you pay.
Local Deslop CLI and MCP server. Sign in with your Deslop account to activate this plan.
Includes one Personal License (full local CLI + MCP). Add seats as your team grows.
Additional seats: each extra Personal License is $10.99/mo per user.
Under the hood
Deslop operates like a true compiler frontend. A pure Haskell engine ingests your TypeScript alongside your tsconfig.json, distilling raw syntax into normalized semantics—where superficial code variations resolve into a single, unified model. By building a lossless pipeline from exact source tokens to a fully connected, whole-repo graph, it unlocks surgical automated fixes and unbreakable architectural rules.
Concrete Syntax Tree (CST)
Deslop builds a fully lossless CST, retaining all compiler trivia—every whitespace character and comment is accounted for. This allows the engine to round-trip edits directly to the original source text without destroying your formatting or causing noisy diffs.
Abstract Syntax Tree (AST)
The CST is lowered into a semantic AST. This is where structural bindings, control flow, and data flow are computed. It provides a deeper layer of static analysis that goes far beyond the capabilities of standard regex or purely text-based grep tools.
Whole-Repo Dependency Graph
Finally, Deslop resolves cross-file references to assemble a global topological graph of modules, imports, and symbols. This overarching view allows your RuleBook to enforce complex architectural boundaries and systemic invariants that single-file linters simply cannot see.
Linters like Biome and ESLint are phenomenal at single-file AST traversal, stylistic formatting, and localized bug detection. However, they lack a unified, cross-file semantic model. They operate in isolation. When you need to enforce complex architectural contracts—like preventing your domain layer from importing React components—localized AST visitors fall short.
Deslop isn't a replacement; it's a structural complement. Keep your linters for fast, local feedback, and use Deslop as the deterministic, project-wide enforcement layer that guarantees architectural integrity.
Modern AI harnesses like Cursor and Claude Code rely on RAG (Retrieval-Augmented Generation) to understand your repository. They chunk code based on text embeddings, which is inherently probabilistic and easily fragmented. Vector search frequently misses crucial edge cases, buried import chains, or implicit type dependencies, resulting in hallucinatory refactors.
Deslop solves this by exposing a complete, deterministic graph via MCP (Model Context Protocol). Instead of guessing based on semantic similarity, agents can query exact topological contexts, ensuring AI-generated code perfectly aligns with your pipeline's architectural rules.
Built in Haskell. Purely functional and mathematically correct — bringing strict determinism to our increasingly non-deterministic, LLM-driven world.
Deslop reports errors in a LLM-friendly Markdown format with clear instructions on how to fix them. Perfect for integration with Cursor, Claude Code, Codex, or your custom MCP server.
# /src/app/[locale]/dashboard/settings/security/mfa/page.tsx: no-relative-imports
Relative imports are not allowed. Use absolute path aliased ones.
```ts
import { assertOrgRole } from '../../../../lib/auth/rbac';
```
FIX: Use `import { assertOrgRole } from '@/lib/auth/rbac';` instead.
---------Join 500+ developers turning fragmented AI output into clean, maintainable, and architectural code.