What makes slop-detector notable?

1.6K downloads. Trust evidence available

How should slop-detector be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

slop-detector

Detects AI-generated writing patterns in prose Skill: slop-detector Owner: athola Summary: Detects AI-generated writing patterns in prose Tags: latest:1.9.19 Version history: v1.9.19 | 2026-08-26T13:22:04.989Z | user Release v1.9.19 v1.9.17 | 2026-07-30T05:42:01.025Z | user Release v1.9.17 v1.9.16 | 2026-07-14T19:58:50.789Z | user Release v1.9.16 v1.9.14 | 2026-06-30T18:06:29.352Z | user Release v1.9.14 v1.9.13 | 2026-06-27T16:24:12.634Z | user Release v1.9.13 v1

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.6k

Updated

Oct 10, 2026

Version

1.9.19

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.6K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.6K downloadsadoption · observed Oct 10, 2026
Latest release: 1.9.19release · observed Aug 26, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17emme0e2m3cpf7k2jvp3a84984b8z9:nm-scribe-slop-detector

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-athola-nm-scribe-slop-detector/snapshot"

Documentation

CLAWHUB

147,987 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: slop-detector
description: Detects AI-generated writing patterns in prose
version: 1.9.8
triggers:
  - ai-detection
  - slop
  - writing
  - cleanup
  - documentation
  - quality
  - reviewing docs for slop
  - vague language
  - or identity leaks before publishing
metadata: {"openclaw": {"homepage": "https://github.com/athola/claude-night-market/tree/master/plugins/scribe", "emoji": "\u270d\ufe0f", "requires": {"config": ["night-market.scribe:shared"]}}}
source: claude-night-market
source_plugin: scribe
---

> **Night Market Skill** — ported from [claude-night-market/scribe](https://github.com/athola/claude-night-market/tree/master/plugins/scribe). For the full experience with agents, hooks, and commands, install the Claude Code plugin.


# AI Slop Detection

**Slop is a density problem, not a word problem.**

A single "delve" is fine. Five "delves" near a "tapestry"
and an "embark" is generated text. This skill scores
density per 100 words, marker clustering, and whether
the overall register fits the document type. It does not
ban words; it flags concentrations.

## Execution Workflow

Identify target files and classify them as technical docs,
narrative prose, or code comments. Classification feeds
context-aware scoring: tier-1 markers in marketing copy
score lower than the same markers in API reference.

### Language Detection

- Auto-detect language from text content using function word frequency
- Override with explicit `--lang` parameter (en, de, fr, es)
- Load language-specific patterns from `data/languages/{lang}.yaml`
- Fall back to English if detection confidence is low
- See `modules/language-handling.md` for cultural calibration and concrete pattern sets

### Vocabulary and Phrase Detection

Load: `@modules/vocabulary-patterns.md`

Markers fall into three confidence tiers. Tier 1 words
("delve", "multifaceted", "leverage") appear far more often
in AI text than human text. Tier 2 covers context-dependent
transitions ("moreover", "subsequently"). Tier 3 covers
vapid phrases ("In today's fast-paced world", "cannot be
overstated").

| Word | Context | Human Alternative |
|------|---------|-------------------|
| delve | "delve into" | explore, examine, look at |
| tapestry | "rich tapestry" | mix, combination, variety |
| realm | "in the realm of" | in, within, regarding |
| embark | "embark on a journey" | start, begin |
| beacon | "a beacon of" | example, model |
| spearheaded | formal attribution | led, started |
| multifaceted | describing complexity | complex, varied |
| comprehensive | describing scope | thorough, complete |
| pivotal | importance marker | key, important |
| nuanced | sophistication signal | subtle, detailed |
| meticulous/meticulously | care marker | careful, detailed |
| intricate | complexity marker | detailed, complex |
| showcasing | display verb | showing, displaying |
| leveraging | business jargon | using |
| streamline | optimization verb | simplify, improve |

### Tier 2: Medium-Confidence Markers

_meta.json

{
  "ownerId": "kn7d107jg9jv602h9ytsegydq184a42s",
  "slug": "nm-scribe-slop-detector",
  "version": "1.9.19",
  "publishedAt": 1787750524989
}

modules/anti-goals.md

---
module: anti-goals
category: safety
dependencies: [Read]
estimated_tokens: 500
---

# Anti-Goals: What NOT to Clean Up

**Aggressive de-slopping has its own failure modes.**

This module is the safety rail. Every other module in the
slop-detector tells you what to flag and remove; this one
tells you what to *leave alone* even when it pattern-
matches. The bar for deletion is higher than the bar for
flagging.

When in doubt: leave it alone, surface it as a finding,
and let a human decide.

## Class 1: Comments that earn their bytes

These look like slop on density alone but carry meaning
the code does not:

### Why-comments (always keep)

A comment that explains *why* a non-obvious decision was
made is the highest-value comment class. The code is the
"what"; comments earn their place by carrying the "why".

```rust
// We sleep 200ms specifically because the upstream
// rate-limiter buckets at 5/s; faster retries return
// 429 and waste a slot:
thread::sleep(Duration::from_millis(200));
```

This pattern-matches as a "magic constant with comment"
which §3.2 flags as marketing slop, but it is the
*opposite* of slop: the comment names the constraint that
makes the constant correct.

**Rule**: a comment that names a constraint, references an
upstream contract, or explains a counter-intuitive choice
is information the code cannot carry. Keep it.

### Safety comments on `unsafe` blocks (always keep)

```rust
// SAFETY: the caller has already validated that `idx`
// is within `slice.len()`; see the bounds check in
// `Buffer::insert` two frames up:
unsafe { *slice.as_ptr().add(idx) }
```

These are *required* by `clippy::undocumented_unsafe_blocks`
and are part of the contract the code makes with reviewers.
Stripping them removes the only proof the unsafe block is
correct.

### Structured-meaning comment prefixes (always keep)

Many codebases adopt structured prefixes for specific
comment classes. Examples:

```
// SAFETY: ...
// INVARIANT: ...
// LOCK ORDER: ...
// BLOCKING: ...
// PERFORMANCE: ...
// SECURITY: ...
// THREAD: ...
```

These are project-specific contracts. They are not slop
even if they look formulaic: the formula *is* the
contract. Audit before stripping; do not strip on pattern
match alone.

### Regression-pinning tests (always keep)

A test that looks trivial (`assert!(parse("").is_err())`)
may be pinning a regression. Deleting it because it "looks
slop" is exactly how the regression returns.

**Rule**: tests with bug-tracker references in their name
or comment (`test_regression_1234`, `// repro for #1234`)
must not be removed without an explicit decision that the
regression class is no longer relevant.

## Class 2: Code that should not be flattened

### `thiserror`-style error variants (do not collapse)

```rust
#[derive(Error)]
pub enum Error {
    #[error("connection refused")]
    ConnectionRefused,
    #[error("timeout after {0}s")]
    Timeout(u64),
    #[error("invalid response: {0}")]
    InvalidResponse(String),
    // ..

modules/ci-integration.md

---
module: ci-integration
category: automation
dependencies: [Bash]
estimated_tokens: 500
---

# CI Integration

Use the `--ci` flag to produce machine-readable output and exit with a non-zero code when
slop density exceeds a threshold. Intended for use in GitHub Actions and pre-commit hooks.

## Flags

| Flag | Default | Description |
|------|---------|-------------|
| `--ci` | off | Emit JSON output instead of the markdown report |
| `--threshold <float>` | `3.0` | Score above which the run fails (exit code 1) |

## JSON Output Schema

When `--ci` is set, write a single JSON object to stdout:

```json
{
  "files": [
    {
      "path": "docs/guide.md",
      "score": 2.4,
      "rating": "Light",
      "markers": 7
    }
  ],
  "summary": {
    "total_files": 1,
    "avg_score": 2.4,
    "max_score": 2.4,
    "pass": true
  }
}
```

### Field Definitions

| Field | Type | Description |
|-------|------|-------------|
| `files[].path` | str | Path to the scanned file (relative to repo root) |
| `files[].score` | float | Slop density score (0–10+) |
| `files[].rating` | str | One of: Clean, Light, Moderate, Heavy |
| `files[].markers` | int | Total marker count in the file |
| `summary.total_files` | int | Number of files scanned |
| `summary.avg_score` | float | Mean score across all files |
| `summary.max_score` | float | Highest score across all files |
| `summary.pass` | bool | True when max_score <= threshold |

## Exit Codes

| Code | Meaning |
|------|---------|
| 0 | All files pass (max_score <= threshold) |
| 1 | One or more files exceed the threshold |
| 2 | Execution error (file not found, parse failure, etc.) |

## Instructions for Claude

When `--ci` appears in the invocation:

1. Run the full detection workflow as normal.
2. Collect per-file results: path, score, rating, marker count.
3. Compute summary fields: total_files, avg_score (round to 2 decimal places), max_score.
4. Set `pass` to `true` when `max_score <= threshold`, `false` otherwise.
5. Write the JSON object to stdout. Do not write the markdown report.
6. Report exit code 1 if `pass` is false, 0 if true, 2 on any error.

Do not mix prose with the JSON output. The JSON must be the only content on stdout so
it can be parsed by downstream tools.

## GitHub Actions Example

```yaml
- name: Slop check
  run: |
    result=$(claude -p "Skill(scribe:slop-detector) --ci --threshold 3.0 docs/")
    echo "$result" | jq .
    pass=$(echo "$result" | jq -r '.summary.pass')
    if [ "$pass" != "true" ]; then
      echo "Slop threshold exceeded" >&2
      exit 1
    fi
```

## Pre-commit Hook Example

```yaml
# .pre-commit-config.yaml
- repo: local
  hooks:
    - id: slop-check
      name: Slop density check
      language: system
      entry: bash -c 'claude -p "Skill(scribe:slop-detector) --ci --threshold 3.0" "$@"'
      types: [markdown]
      pass_filenames: true
```

modules/cleanup-workflow.md

---
module: cleanup-workflow
category: methodology
dependencies: [Read, Grep, Bash]
estimated_tokens: 700
---

# Cleanup Workflow

**Run passes in order. Each pass is independent. Commit
between passes. Prefer deletion over rewriting.**

This module gives the multi-pass cleanup methodology. The
order matters: each pass assumes the prior passes have
landed. Mixing concerns within a pass produces diffs that
no reviewer can audit.

## The cardinal rules

1. **One pass per commit.** A commit titled "cleanup"
   that touches comments, prose, error handling, and
   tests is not reviewable. Split.
2. **Deletion beats rewriting.** When in doubt, remove
   the material. AI slop is additive; the cheapest
   correct fix is almost always to take material away.
3. **Cleanup decisions on a compromised baseline are
   themselves compromised.** Run Pass 0 first.
4. **Do not silently apply low-confidence fixes.** Surface
   them as findings, let a human decide (see
   `anti-goals.md`).
5. **Stop when a pass finds nothing.** Do not invent work
   to fill the pass.

## Pass 0: Pre-slop sweep (always first)

Before any cleanup, audit for things that should not be
in the repo at all:

- Committed agent-config files (`CLAUDE.md`, `.cursorrules`,
  `AGENTS.md`, `.codex/config.toml`, `.aider.conf.yml`,
  etc.) with secrets or broad capability grants.
- Committed credentials (run `gitleaks` / `trufflehog`).
- Untrusted MCP server entries.
- Hooks that auto-execute on session start.

Commit any redactions or revocations *before* any other
cleanup, since later passes assume an uncompromised
baseline.

```bash
# Pre-slop sweep checklist
gitleaks detect --no-banner
ls -la | grep -E '^.*(CLAUDE|cursor|codex|aider|kiro)'
find . -name '.mcp' -o -name 'mcp.json' -type f
```

## Pass 1: Surface lint sweep

Run the cheap automated detectors. Fix or delete what
they flag. This is the floor, not the ceiling.

```bash
# Linter floor
[language-specific formatter] --check
[language-specific linter] --strict

# Dependency hygiene
[unused-dep detector]
[vulnerability scanner]
```

Commit. If your linter supports an "no escape hatches"
rule (e.g. `allow_attributes = "deny"` in Rust clippy),
enable it. it prevents the most common AI-agent dodge:
silencing a lint with `#[allow(...)]` instead of fixing
the underlying code.

## Pass 2: Hallucination sweep

Run `Skill(scribe:slop-detector)` module
`hallucination-detection.md`:

- Every quoted identifier in prose: does it exist?
- Every backticked file path: does it exist?
- Every cited URL: does it 200?
- Every recommended package install: does it resolve on
  the relevant registry?
- Every config key in docs: does the code read it?

Then run module `stub-and-deferral.md`:

- Every TODO/FIXME/XXX/HACK: is there a tracked issue
  link, or is the surrounding code path defunct?
- Every `// for now`, `// placeholder`, `// dummy`: same
  question.
- Every `todo!()` / `unimplemented!()` /
  `NotImplementedError`: is this reachable from a public
  AP

Github ReposUpdated 15h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.