Show HN: AISlop, a CLI for catching AI generated code smells

I’m eager to test this out. I have agent instructions to try to limit the worst of this already, but patterns still sneak through. I have a review agent run after every single edit looking for all of the following if you need more ideas for checks:

- DRY principle violations, multiple definitions of the same helpers or utilities.

- Changes that deviate from existing patterns and architecture already in the code, especially in nearby and related code

- Comments that add no context or simply restate the field name.

- Naming violations (enterprise factoryfactoryabstraction stuff, excessively long names, overly technical names, banned words like “seam”, “durable”, and no-value-qualifiers like “SaveGame” -> “Save”).

- Tests that check implementations instead of correct business behavior.

- Overly backwards-compatible unless asked for (this one is incredibly hard to keep under control, as AI loves to guard everything even if the previous code was never deployed and thus there is no contract break)

- Un-necessary guard code (this is hard to control, most common case is the AI not relying on the serializer error handler and instead adding guards that the library already handles)

- Changing public API contracts without express permission to do so (depends on the code, eg a library JAR or versioned REST service)

- Meta references to previous code versions, to tasks or todos, or to instructions and other non-code context (e.g you tell the AI the adder should ignore negative numbers and that meta fact enters the comments or code)

I usually hand review all changes myself but it’s incredibly tedious so I try to first pass with the review agent until it comes back clean. I hate wasting tokens on it though.

Petition to rename this “SlopCop”

Apparently I need to check in with a Doctor because code written by myself is seen as AI, and the lazy AI bits aren't. More Human than Human?

A linter with rules for AI-specific weirdness is absolutely a great idea, thank you! Are there any plans to support other languages besides javascript?

Nice job. Somewhat related, but one "AI smell" (if you can call it that) is LLMs' desire to add layers of redundant safeguards with things like null coalescing operators and defensive fallbacks so that there’s always some default value. LLMs often seem to struggle with the distinction between happy/unhappy paths and often end up treating everything as optional and "safe".

I’m a much bigger fan of surfacing problems like missing values immediately and loudly so they bubble up, particularly during early prototyping and development.

I’ve collected a set of best practices in my AGENTS.md that covers issues like this, and that’s helped a fair bit. Obviously, you want to offload as much as possible to a deterministic linter, but this pattern is a bit tougher to catch in post.

I don’t see if this is one of the covered cases, but one of the more common and nefarious patterns I run into is what you might call "sweeping exceptions under the rug." I think the agent’s motivation to get things running encourages these antipatterns of designing routines that are fault tolerant in a sort of maladaptive way: e.g. catching an error, logging a warning that something didn’t work, and continuing, but with now potentially missing/broken state.

This has bitten me a couple of times, and it’s surprisingly annoying to nudge agents into good/resilient patterns or identify situations that should fail loudly, at least in my experience. The retry mechanisms they come up with on their own are often pretty terrible as well.

I’ll note, though, that I have seen this from human engineers plenty of times, and at least the AI usually adds some logs rather than just totally silently absorbing an exception!

I was about to write what advantage it has over linters but then saw the built on section. Good work. We use megalinter with our flavour of go and vite rules, plus extensive e2e testing after each agent run. Quality of the spec driven agentic PRs are significantly better than the baseline. Megalinter is quite resource heavy and slow, so will definitely check this out

This is a great idea. Even if you're one of those developers squarely focused on getting the final result working, code quality still matters (to people and LLMs).

Everyone should be doing regular code reviews and this helps a lot.