Stop Letting AI Agents Write Slop! Use Desloppify Instead

Your AI agent just shipped a feature in record time. The demo works. The tests pass. Everyone's celebrating—until three weeks later, when you open the codebase and feel that familiar dread. Dead imports littering every file. Functions with names like handleStuff(). The same logic copy-pasted in four places with slightly different variable names. Error handling? Three different patterns, none of them consistent. Welcome to the hidden cost of vibe coding: slop.

Here's the brutal truth nobody wants to admit. AI coding agents are incredible at velocity and terrible at longevity. They'll generate hundreds of lines of working code without a single thought for the engineer who maintains it next quarter. The result? Codebases that function but rot—silently, invisibly, until every new feature takes twice as long as it should.

But what if your agent could do better? What if it had a north star—a score that actually correlates with code quality, not vanity metrics? Enter Desloppify, the agent harness that transforms AI-generated chaos into systematically beautiful engineering. This isn't another linter. This is a complete quality framework that makes your agent care about the code it leaves behind.

What is Desloppify?

Desloppify is an agent harness—a specialized tool designed to give AI coding agents the framework, feedback, and persistence they need to improve codebase quality systematically. Created by Peter O'Malley, it addresses a gap that traditional developer tools completely ignore: how do you make an AI agent write code that seasoned engineers respect?

The project sits at the intersection of two explosive trends: the rise of AI coding agents (Claude, Cursor, Copilot, Codex, and dozens more) and the mounting frustration with the technical debt they generate. While agents have become spectacularly good at producing working code, they've remained blind to the structural and aesthetic dimensions that separate prototype-quality slop from production-grade engineering.

Desloppify solves this by combining mechanical detection with subjective LLM review in a persistent, gamified loop. Mechanical detectors catch objective issues: dead code, duplication, complexity spikes, test coverage gaps. LLM reviewers assess subjective quality: naming consistency, abstraction boundaries, error handling patterns, module cohesion. Both feed into a scoring system designed to resist gaming—the only way to improve your score is to genuinely make the code better.

The tool currently supports 29 languages with deep plugin integration for TypeScript, Python, C#, C++, Dart, GDScript, Go, and Rust. Generic linter and tree-sitter support extends coverage to Ruby, Java, Kotlin, and 18 additional languages. For C++ specifically, it leverages compile_commands.json for precise analysis with Makefile fallback.

What makes Desloppify genuinely innovative is its state persistence. Progress chips away across multiple sessions—the .desloppify/ directory maintains your scan results, execution queue, and improvement history. This isn't a one-and-done report; it's a living quality management system that accompanies your codebase over time.

Key Features That Separate Desloppify from Ordinary Linters

Anti-Gaming Score Architecture. Most code quality tools fail because developers learn to optimize the metric, not the underlying quality. Desloppify's scoring system actively resists this. Wontfix items widen the gap between lenient and strict scores. Re-reviewing dimensions can lower scores if the LLM finds new issues. A score above 98 genuinely correlates with what experienced engineers call beautiful code.

Dual Detection Engine. The mechanical layer runs static analysis across dead code, duplication, complexity metrics, test gaps, and naming violations. The subjective layer deploys LLM reviewers for abstraction quality, module boundaries, error handling consistency, and architectural coherence. Neither alone captures what makes code maintainable; together, they create a complete quality picture.

Persistent Execution Queue. The next command isn't a static todo list—it's a living plan that evolves as you fix issues. State persists across sessions, so you can chip away at improvements over days or weeks without losing context. The backlog command reveals broader open work, while plan and plan queue let you reorder priorities and cluster related issues for efficient batch fixing.

Agent-Native Workflow. Desloppify isn't built for human developers clicking through GUIs. It's built for agents executing commands. The update-skill command installs complete workflow guides tailored to specific agents: Claude, Cursor, Codex, Copilot, Droid, Windsurf, Gemini, RovoDev. Each skill teaches the agent how to interpret findings, prioritize fixes, and maintain momentum through the execution loop.

CI/CD Integration. The --profile ci flag transforms Desloppify from an interactive improvement tool into a health gate for your pipeline. It skips slow subjective phases and bypasses mid-cycle scan queue gates, producing a fresh mechanical snapshot that enforces codebase standards on every pull request.

Scorecard Badge Generation. Hit your quality target? Desloppify generates a badge for your GitHub profile or README—a public signal that your codebase meets genuine engineering standards, not just passing tests.

Real-World Use Cases Where Desloppify Shines

Rescuing Vibe-Coded MVPs. You've got a working prototype built with AI assistance, and now you need to productionize it. The code "works" but you know it's held together with architectural duct tape. Desloppify scans the entire codebase, identifies the structural rot hiding beneath functional correctness, and guides systematic remediation. The score gives investors, teammates, and your future self confidence that the foundation is solid.

Onboarding AI Agents to Legacy Codebases. Throwing an AI agent at an unfamiliar codebase typically produces surface-level fixes or dangerous refactors. Desloppify gives the agent contextual understanding—it sees the full quality landscape, prioritizes interventions by impact, and maintains persistent state so the agent doesn't revisit solved problems or lose track of dependencies between fixes.

Maintaining Quality in High-Velocity Teams. When multiple developers (human or AI) contribute rapidly, quality standards erode through accumulated micro-decisions. Desloppify acts as an automated quality anchor, running in CI to catch degradation before it compounds. The strict score prevents the gradual "boiling frog" decline that makes codebases unmaintainable.

Multi-Language Monorepos. Modern projects combine TypeScript frontends, Python backends, Go microservices, and Rust performance modules. Desloppify handles each with language-appropriate depth while maintaining separate state per language. Scan your frontend and backend individually without cross-contamination, or run matrix CI jobs for comprehensive coverage.

Open Source Project Health Signals. For maintainers seeking to attract contributors and institutional trust, the Desloppify scorecard badge provides verifiable quality evidence. Unlike arbitrary "active development" badges or test coverage percentages that hide structural problems, this score reflects genuine engineering craftsmanship.

Step-by-Step Installation & Setup Guide

Getting Desloppify operational takes minutes, but proper setup ensures your agent gets maximum value from the harness.

Prerequisites

Desloppify requires Python 3.11 or higher. Verify your version:

python --version  # Must show 3.11.x or higher

Installation

Install with full dependencies for complete language support:

pip install --upgrade "desloppify[full]"

The [full] extra includes all language plugins and detectors. For constrained environments, you can install a minimal version and add plugins selectively.

Agent Skill Installation

Teach your specific AI agent the Desloppify workflow:

desloppify update-skill claude    # Options: claude, cursor, codex, copilot, droid, windsurf, gemini, rovodev

This installs a complete workflow guide tailored to your agent's context window and tool-use patterns. The skill teaches the agent how to interpret scan output, prioritize the execution queue, and maintain proper fix discipline.

Repository Configuration

Add state directory to .gitignore:

echo ".desloppify/" >> .gitignore

This directory contains local scan state, execution queues, and cached reviews that shouldn't be committed.

Exclusion Setup

Before scanning, identify directories that should be excluded:

desloppify exclude vendor
desloppify exclude build
desloppify exclude dist
desloppify exclude "*.generated.*"

Common exclusions include vendor directories, build output, generated code, and git worktrees. Exclude obvious candidates immediately; flag questionable ones for human review.

Initial Scan and First Fix Cycle

Launch the complete quality assessment:

desloppify scan --path .

The --path argument accepts . for the entire project or subdirectories like src/ for targeted analysis. For monorepos with multiple programs, scan each separately:

desloppify --lang typescript scan --path ./frontend
desloppify --lang python scan --path ./backend

Begin the fix loop:

desloppify next

This reveals the highest-priority fix from your triaged queue. Implement the change, then resolve:

desloppify resolve

Repeat: next → fix → resolve → next. This loop is your primary quality improvement engine.

REAL Code Examples: Desloppify in Action

Let's examine practical implementations drawn directly from the Desloppify repository documentation.

Example 1: Complete Agent Prompt for Codebase Improvement

This is the exact prompt the README recommends pasting into your AI agent. Study its structure—it encodes critical workflow patterns:

I want you to improve the quality of this codebase. To do this, install and run desloppify.
Run ALL of the following (requires Python 3.11+):

pip install --upgrade "desloppify[full]"
desloppify update-skill claude    # installs the full workflow guide — pick yours: claude, cursor, codex, copilot, droid, windsurf, gemini, rovodev

Add .desloppify/ to your .gitignore — it contains local state that shouldn't be committed.

Before scanning, check for directories that should be excluded (vendor, build output,
generated code, worktrees, etc.) and exclude obvious ones with `desloppify exclude <path>`.
Share any questionable candidates with me before excluding.

desloppify scan --path .
desloppify next

--path is the directory to scan (use "." for the whole project, or "src/" etc).

Your goal is to get the strict score as high as possible. The scoring resists gaming — the
only way to improve it is to actually make the code better.

THE LOOP: run `next`. It is the execution queue from the living plan, not the whole backlog.
It tells you what to fix now, which file, and the resolve command to run when done.
Fix it, resolve it, run `next` again. Over and over. This is your main job.

Use `desloppify backlog` only when you need to inspect broader open work that is not currently
driving execution.

Don't be lazy. Large refactors and small detailed fixes — do both with equal energy. No task
is too big or too small. Fix things properly, not minimally.

Use `plan` / `plan queue` to reorder priorities or cluster related issues. Rescan periodically.
The scan output includes agent instructions — follow them, don't substitute your own analysis.

Why this matters: The prompt establishes agent discipline. Notice the explicit instruction to follow scan output rather than substituting the agent's own analysis—this prevents the agent from "helpfully" reinventing priorities and missing systematic improvements. The emphasis on equal energy for large and small fixes combats the agent tendency to cherry-pick easy wins while ignoring structural debt.

Example 2: Monorepo Language-Specific Scanning

When your workspace contains multiple programs, targeted scanning prevents quality context contamination:

# Scan TypeScript frontend with full plugin depth
desloppify --lang typescript scan --path ./frontend

# Scan Python backend with Python-specific detectors
desloppify --lang python scan --path ./backend

Critical insight: The --lang flag ensures appropriate detectors run for each codebase's paradigm. Scanning the parent directory would corrupt state—mechanical issues from your frontend's node_modules might influence Python scoring, and path contexts would become unreliable. Desloppify maintains separate state per language automatically, but you must target coherent project boundaries.

Example 3: CI Pipeline Health Gate

For production-grade quality enforcement, integrate Desloppify into your continuous integration:

# Run CI-optimized scan: skips subjective phases, bypasses queue gate
desloppify scan --path . --profile ci --no-badge

# Extract machine-readable status for threshold enforcement
desloppify status --json

The --profile ci flag is essential for automation. It eliminates the LLM review phase (too slow and non-deterministic for gates) and bypasses the interactive queue gate that would stall a CI job. The --no-badge flag prevents README badge generation in ephemeral CI environments.

Example 4: Complete GitHub Actions Workflow

Here's the minimal GitHub Actions configuration from the repository, annotated with implementation details:

name: desloppify

on:
  pull_request:      # Run on every PR to catch quality regressions
  push:
    branches: [main]  # Run on main to track baseline health

jobs:
  health:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"  # Hard requirement: 3.11+
      
      # Install with full plugin suite
      - run: pip install --upgrade "desloppify[full]"
      
      # CI scan: mechanical only, fast, deterministic
      - run: desloppify scan --path . --profile ci --no-badge
      
      # Extract scores for custom threshold enforcement
      - run: desloppify status --json

Production note: For monorepos, replace the single scan with a matrix strategy—one job per project path. True incremental scanning isn't supported yet; compare full-codebase results across runs or enforce project-level thresholds.

Example 5: Environment Tuning for Constrained Runners

Java CI runners with limited resources need special configuration:

# Default: disables PMD worker threads to prevent resource exhaustion
# Set explicitly for controlled parallelism:
export DESLOPPIFY_PMD_THREADS=2        # Fixed thread count
# OR
export DESLOPPIFY_PMD_THREADS=0.5C     # Half available cores

This environment variable controls the PMD static analyzer's worker thread allocation. On memory-constrained runners, the default --threads 0 prevents out-of-memory crashes from thread fanout. Scale up only when you've verified runner capacity.

Advanced Usage & Best Practices

Master the Triage Phase. The biggest mistake users make is skipping from scan straight to next without triage. The initial queue is impact-sorted but noisy—similar issues scattered across files, false positives from generated code, and low-hanging fruit masking structural problems. Use plan to cluster related issues and plan queue to reorder by implementation efficiency. A 20-minute triage session often saves hours of fragmented fixing.

Rescan Strategically, Not Obsessively. Rescanning after every single fix is tempting but inefficient. The tool is designed for periodic verification—fix a coherent cluster, then rescan to catch cascading effects and validate improvements. Frequent rescans on large codebases waste compute without proportional insight.

Leverage the Strict/Lenient Score Gap. When wontfix items accumulate, watch the gap between strict and lenient scores widen. This is intentional anti-gaming design—you can't indefinitely defer hard fixes without score consequences. Use this gap as a technical debt thermometer.

Agent Discipline Over Agent Speed. The prompt explicitly warns against laziness. In practice, this means preventing your agent from applying minimal patches that satisfy the immediate complaint without addressing root causes. When Desloppify flags duplicated logic, the fix isn't "extract one instance"—it's "design the correct abstraction and migrate all call sites."

CI Baseline Tracking. Store status --json outputs as build artifacts and trend scores over time. A flat or declining strict score despite active development signals quality erosion that needs immediate attention.

Comparison with Alternatives

Why Desloppify wins for AI-augmented development: Traditional tools assume human developers interpreting reports. Desloppify assumes agents executing loops—the entire workflow is designed for autonomous or semi-autonomous operation. The persistent state, the next/resolve command structure, and the agent-specific skill installations have no equivalent in conventional tooling.

The subjective LLM review layer is equally unique. Linters catch var vs const; Desloppify's reviewer assesses whether that variable should exist at all, whether its name reveals intent, whether its scope boundary is coherent. This is senior engineer judgment, automated.

Frequently Asked Questions

What makes Desloppify different from running a linter in CI? Linters enforce rules; Desloppify pursues quality as an optimization target. The score correlates with maintainability, not just rule compliance. Plus, the agent harness, persistent state, and subjective review layers have no linter equivalent.

Can I use Desloppify without an AI agent? Absolutely. The CLI is fully functional for human developers. However, the workflow is optimized for agent execution—the next command assumes you'll process many items sequentially, and the skill installations are agent-specific.

Why does the score sometimes decrease after fixes? This is anti-gaming in action. Re-reviewing dimensions can expose issues previously masked by worse problems. A temporary score decrease often signals that you're now operating at a higher quality threshold where subtler issues become visible.

How long does a full scan take? Depends on codebase size and language. The --profile ci flag dramatically reduces time by skipping LLM review. For reference, mechanical-only scans on medium codebases (50-100k lines) typically complete in 2-5 minutes.

Is Desloppify free for commercial use? Free for individuals regardless of context, and free for open-source companies in any capacity. Non-open-source companies should consult the LICENSE for transparent commercial pricing.

What if my language isn't in the deep plugin list? Generic tree-sitter and linter support covers 21 additional languages with baseline mechanical detection. File an issue or PR for deep plugin expansion—community contributions are actively welcomed.

How do I prevent the agent from gaming the score? The scoring architecture resists gaming by design. Wontfix items widen strict/lenient gaps. Re-reviews can lower scores. The only reliable path to improvement is genuine quality enhancement—exactly as intended.

Conclusion: From Vibe Coding to Vibe Engineering

The AI coding revolution has given us unprecedented velocity. What it hasn't given us is longevity—the discipline, structure, and aesthetic coherence that separates prototypes from products. Desloppify bridges that gap without sacrificing speed.

This tool embodies a crucial insight: LLMs are capable of genuine engineering judgment when given the right framework. The score isn't a vanity metric to optimize with tricks. It's a compass pointing toward maintainability, calibrated to resist manipulation and reward authentic improvement.

Whether you're rescuing a vibe-coded MVP, enforcing standards in a high-velocity team, or proving quality to skeptical stakeholders, Desloppify provides the infrastructure that AI-native development desperately needs. The badge on your README won't just signal passing tests—it'll signal craftsmanship.

Ready to stop accepting slop? Install Desloppify today, run your first scan, and discover what your codebase could become. Your future self—and every engineer who touches your code after you—will thank you.

Join the community of vibe engineers building beautiful things: Discord