AI Is Rotting Your Codebase

AI isn't just generating code; it's generating AI slop, a silent killer of codebase integrity. This isn't merely bad code; it's a tragedy of the commons—code that appears polished and functional but is architecturally flawed, riddled with duplicated patterns, and accelerates technical debt. Its insidious nature lies in its ability to erode your project from within, even while passing basic checks.

Quantifying the damage reveals a stark reality. GitClear's analysis across 211 million lines of code found AI-heavy projects exhibit a 4-8x increase in duplicated code blocks. Refactoring efforts collapse by 60%, and churn rates skyrocket 9x compared to human-written code. These aren't minor inefficiencies; they're structural degradations.

The core danger: this low-quality output easily slips past human review, appearing valid on superficial inspection. It silently propagates architectural flaws and inflated complexity throughout the codebase. This externalizes massive maintenance costs onto future teams, forcing them to untangle a mess that never should have reached production.

Common wisdom dictates prompt files like [Claude](/en/anthropic-workbench).md suffice for AI agent guidance. Teams meticulously craft these to embed 'soft' rules and architectural suggestions. The intent is clear: steer generative AI toward quality, prevent AI slop.

But this approach is fundamentally unreliable. Agents can, and often will, ignore these directives when they don't 'see another way out'—a common occurrence in complex code generation. This leads to non-deterministic output quality, where a seemingly compliant agent suddenly introduces duplicated patterns or any typecasting, defying its own prompt.

The problem isn't lazy engineers. It's a systemic tooling failure. Relying on human vigilance to catch subtle architectural flaws or inconsistent patterns introduced by AI at scale is an unwinnable battle. GitClear data shows AI-heavy code sees a 4-8x increase in duplicated code blocks and a 60% collapse in refactoring.

These soft guardrails offer a false sense of security. They accelerate technical debt by allowing AI-generated code, polished on the surface but architecturally unsound, to silently rot the codebase. Your best intentions, codified in Claude.md, are simply not enough against an agent determined to find a solution, not necessarily the best solution.

Enter anti-slop: your new quality gate. This specialized set of opinionated linting rules directly targets common AI-generated anti-patterns in TypeScript. It combats low-evidence code like pervasive any typecasting, nested type assertions, and broad object parameter types, often invisible during superficial review.

Unlike soft Claude.md guidelines, anti-slop generates hard, unignorable linting errors. When an AI agent outputs flawed code, it receives precise, deterministic feedback with specific remediation hints. This forces the agent to repair the code, establishing a powerful, iterative quality loop that prevents architectural flaws and duplicated patterns from ever reaching production.

Crucially, anti-slop leverages Oxlint, a high-performance Rust-based linter, delivering feedback 50 to 100 times faster than ESLint. This extreme performance is non-negotiable for agentic workflows, providing the instant validation needed to steer AI agents effectively towards robust, maintainable code. For a deeper dive into specific rules—like rejecting conditional empty object spreading—and its implementation, check out the project's GitHub repository: GitHub - dmmulroy/anti-slop: Opinionated Oxlint rules for rejecting low-evidence TypeScript and JavaScript patterns.

Anti-slop's philosophy treats type safety as evidence, not decoration. These rules aren't suggestions; they're hard compiler stops. Expect rejections for patterns like nested type assertions, module mocks, and broad object parameter types. Instead, Anti-slop demands clear boundary parsing and explicit safety comments for non-const type assertions, forcing agents to build robust systems, not just passable syntax.

This isn't some black-box dependency. Anti-slop utilizes a vendored implementation model. Teams copy the ruleset directly into their repository, making it part of their codebase. This allows deep customization, tailoring standards to specific project needs rather than conforming to a rigid external package. It's about owning your quality gate.

Anti-slop sits within a growing industry recognition of AI slop's insidious threat. Similar tools are emerging, and discussions around AI-induced technical debt are amplifying. GitClear data, for instance, showed AI-heavy code experiencing 4-8x increases in duplicated blocks and a 60% collapse in refactoring. The problem is real, and hard rules are the only fix.

What is 'AI slop'?

AI slop is AI-generated code that is syntactically correct and may pass basic tests, but is architecturally unsound. It often includes duplicated patterns, inflated complexity, and poor practices that accelerate long-term technical debt.

How does the Anti-slop linter work?

Anti-slop is a set of opinionated linting rules for the high-speed linter Oxlint. It creates hard, unignorable errors when it detects low-quality code patterns common in AI output, forcing the AI agent to fix the code using specific feedback.

Why is Anti-slop better than using good prompts or instructions?

Prompts and documentation files are 'soft' guidelines that AI agents can ignore, especially when they can't find another solution. Anti-slop creates deterministic, hard errors that cannot be bypassed, acting as an effective quality gate.

What is Oxlint and why is it important for Anti-slop?

Oxlint is a JavaScript/TypeScript linter built in Rust, making it 50-100 times faster than ESLint. This extreme speed is crucial for providing the instant feedback AI agents need to iteratively repair code without slowing down the development workflow.