slopfence

A fast, deterministic quality gate for AI-assisted code.

slopfence finds the junk that AI coding assistants leave behind (hallucinated packages, tests that test nothing, placeholder stubs, duplicate helpers) before it gets merged.

🚧 Status: alpha (v0.1, Python only). The first detectors work and are tested against 20,000+ files of real-world code for false positives. Expect rough edges. Feedback is very welcome. See Contributing.

Quick start

pip install slopfence

Or run it without installing, using uv or pipx:

uvx slopfence .
pipx run slopfence .

Check a project:

slopfence .

Check only what your branch changed (ideal for pull requests):

slopfence --diff main

Options

Exit codes: 0 no issues, 1 issues found, 2 error.

Configuration

Add a [tool.slopfence] table to the pyproject.toml at your project root:

[tool.slopfence]
select = ["SLOP001", "SLOP010", "SLOP020"]  # rules to run (default: all)
ignore = ["SLOP051"]                         # rules to skip
exclude = ["migrations", "tests/fixtures/", "*_pb2.py"]

exclude works like .gitignore: a pattern without a / in the middle matches any file or folder name anywhere (migrations, *_pb2.py), and a pattern with one is relative to the project root (tests/fixtures/). Excluded files are never checked, but imports of excluded modules still count as your own code.

Command-line options (--select, --ignore, --exclude) replace the matching config values. Unknown keys and rule IDs are reported as errors (exit code 2).

Ignoring a finding

# In a real implementation, use the cache.  # slopfence: ignore[SLOP010]
x = legacy()  # slopfence: ignore

Put # slopfence: ignore-file anywhere in a file to skip it. In requirements.txt, add # slopfence: ignore to a line.

GitHub Action

# .github/workflows/slopfence.yml
name: slopfence
on: pull_request
permissions:
  contents: read
jobs:
  slopfence:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - uses: syedmuhdahmad/slopfence@v0.1.1

On pull requests it automatically checks only the changed lines (set diff: none to check everything, or diff: <ref> for a specific ref). To show findings inline on the pull request, set sarif-file: slopfence.sarif and upload it with github/codeql-action/upload-sarif (needs security-events: write).

pre-commit

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/syedmuhdahmad/slopfence
    rev: v0.1.1
    hooks:
      - id: slopfence

The problem

AI coding tools (Claude, Copilot, Cursor, Gemini, Codex and others) are now part of everyday development. They write code fast, and that code usually looks correct. It compiles, it's well formatted, and it has comments and tests.

But it often comes with recognizable junk:

• Packages that don't exist. The AI imports flask-jwt-simple-auth because the name sounds plausible. Attackers now register these invented names to spread malware, a technique known as slopsquatting.
• Tests that test nothing. A test creates a mock, sets a value on it, then asserts that value. It passes forever and protects nothing.
• Placeholder code shipped as real code. Comments like # In a real implementation, validate the token above a function that returns True.
• Duplicate helpers. format_date(), formatDate() and date_formatter() in three different files, because the AI wrote a new helper instead of finding the existing one.
• Over-defensive code. try/except Exception: pass around code that can't fail, which hides real errors.
• Comment noise. # Increment counter by 1 above counter += 1, or leftover chat text like "Here's the updated function:".

Reviewers miss these because the code looks fine. Each one is small. Together they add up to security holes, false confidence from green test suites, and codebases that get harder to maintain every sprint.

Why existing tools aren't enough

No single tool focuses on the failure modes of AI-written code, built for reviewing pull requests. That's the gap slopfence fills.

slopfence vs. AI reviewers: complementary, not competing

Developer + AI writes code
        │
        ▼
slopfence            ← fast, free, same result every time; runs on every commit
        │
        ▼
AI / LLM review      ← deep reasoning about logic and design
        │
        ▼
Human review

AI reviewers are smart but nondeterministic and cost money on every run. slopfence catches the objective, repeatable problems in seconds with no API keys, so reviewers (human or AI) can spend their attention on what matters.

Who needs it

• Teams adopting AI coding tools that want a safety net without banning the tools.
• Open-source maintainers reviewing a growing number of AI-generated pull requests.
• Security teams worried about hallucinated or slopsquatted dependencies.
• Tech leads who want an objective quality gate instead of arguing over style in review.
• Solo developers who want to catch their AI assistant's mistakes before they commit.

Design principles

1. Detect patterns, not authorship. slopfence never tries to guess whether AI wrote the code. That's unreliable and leads to arguments. It flags low-quality patterns that AI commonly produces, no matter who wrote them.
2. Deterministic by default. Rule-based checks with no LLM required. The same input always gives the same output.
3. Diff-first. Check only what changed in a pull request. Nobody wants 4,000 warnings on an old codebase.
4. Low false positives over high recall. A noisy linter gets uninstalled. Start strict, flag only obvious cases, and make everything configurable.
5. Fits existing workflows. CLI, pre-commit hook, GitHub Action, and SARIF output for GitHub code scanning.

Detectors

Example output

$ slopfence --diff main

src/auth.py
  12:1   SLOP001  Package 'flask-jwt-simple-auth' not found on PyPI (possible hallucination)  🔴
  48:5   SLOP010  Placeholder: "In a real implementation, validate the token"            🟠

tests/test_user.py
  20:5   SLOP020  Test only asserts on its own Mock - doesn't test real code               🔴

tests/test_billing.py
  31:5   SLOP022  Test 'test_refund' catches assertion failures without re-raising, so it can never fail  🔴

4 issues (3 high, 1 medium)

Architecture

┌─────────────┐   ┌──────────────┐   ┌──────────────┐   ┌───────────────┐
│   Files /   │──▶│    Parser    │──▶│  Rule engine │──▶│   Reporter    │
│   git diff  │   │ (ast / t-s)  │   │  (detectors) │   │ CLI/JSON/SARIF│
└─────────────┘   └──────────────┘   └──────┬───────┘   └───────────────┘
                                            │
                                  ┌─────────▼─────────┐
                                  │ Optional:         │
                                  │ - registry lookup │
                                  │   (cached)        │
                                  │ - LLM second      │
                                  │   opinion (--llm) │
                                  └───────────────────┘

• Parser: v0.1 uses Python's built-in ast and tokenize (no dependencies). tree-sitter is planned so new languages can be added without rewriting the detectors.
• Registry lookups are cached locally (~/.cache/slopfence) to stay fast and avoid rate limits. If PyPI can't be reached, nothing is flagged: an unknown answer is never treated as "missing".
• Optional LLM mode sends only the unclear cases for a second opinion. Never required.

Challenges (and how we plan to handle them)

Roadmap

v0.1 (MVP): Python

• CLI: slopfence . and slopfence --diff <branch>
• SLOP001 packages that don't exist on PyPI (dependency files and imports)
• SLOP010 placeholder comments
• SLOP020 / SLOP021 / SLOP022 fake tests
• SLOP051 leftover chat text
• Ignore comments
• JSON and SARIF output
• GitHub Action and pre-commit hook
• Publish to PyPI

v0.2

Tracked in the v0.2.0 milestone and on the roadmap board.

Planned features

• Config file: [tool.slopfence] in pyproject.toml (#10)
• SLOP030 near-duplicate functions (#11)
• Parallel processing for large repos (#12)

Reliability

• Test the GitHub Action in a real workflow, including SARIF upload (#13)
• Test the pre-commit hook with pre-commit (#14)
• Allowlist for private packages (#15)
• Better import-name to package-name mapping (#16)
• Detect private indexes from pip.conf, uv and Poetry (#17)
• --fail-on severity threshold (#18)
• Option to fail on unparseable files (#19)
• Fewer SLOP010 false positives from "for demo purposes" (#20)

New rules

• SLOP040 except Exception that silently swallows errors (#21)
• SLOP011 stub functions that only pass or return fake data (#22)
• SLOP050 comments that only restate the code (#23)

Project

• Demo GIF in the README (#24)
• Release v0.2.0 (#25)

Later

• JavaScript / TypeScript (npm registry)
• Slopsquatting risk scoring (SLOP002)
• VS Code extension
• Optional --llm second opinion

Contributing

The project is at the very start, which is the best time to shape it.

• 💡 Have an example of AI-generated junk? Open an issue with a code snippet. Real examples are the most valuable input for designing detectors.
• 🐛 Know a pattern we're missing? Propose a detector in an issue.
• 🗣️ Disagree with the approach? Open a discussion. Better now than after v1.

Please read CONTRIBUTING.md before opening a pull request. Everyone taking part is expected to follow our Code of Conduct. Found a security issue? Report it privately as described in SECURITY.md. Need help? See SUPPORT.md.

License

MIT