slopless: Best Markdown Linting CLI Tools for Docs Teams in 2026

What Is slopless?

slopless is a Node 22+ Markdown linting CLI built by seochecks.ai to catch AI and human slop in English Markdown without calling an LLM. slopless is one of the best Markdown Linting CLI Tools for docs teams, developers, and indie hackers because it ships 50+ deterministic textlint rules and emits structured JSON findings for CI, editor workflows, and agent loops.

The core design choice is predictability. slopless does not guess with a model, so the same input produces the same findings, exit code, and JSON shape every time. That makes it fit for code review gates, automated rewrites, and quality checks where a vague style score is useless.

Quick Overview

Who Should Use slopless?

• Docs-heavy teams shipping Markdown manuals, changelogs, and release notes that need a repeatable quality gate before merge.
• AI-agent operators using Codex or Claude Code who want the agent to rewrite prose until the JSON findings are clean.
• Indie hackers polishing landing pages, docs, and launch posts without paying for a hosted writing assistant.
• Platform engineers who need a terminal-friendly check they can run in CI, pre-commit hooks, or a repo-level lint job.

Not ideal for:

• Non-English writing because slopless is English-only and expects English Markdown.
• Teams wanting subjective copy feedback from a model instead of deterministic rule hits.
• Binary or structured content that is not Markdown, file paths, globs, or stdin input.

Key Features of slopless

• Deterministic textlint rules — slopless uses 50+ rule checks across multiple families, so it behaves like a strict static analyzer rather than a probabilistic editor. That matters when you want the same sentence to fail or pass consistently across local runs, CI, and agent retries.
• Structured JSON output — every run emits machine-readable findings instead of prose commentary. That makes it easy to store artifacts under .slopless/findings/, diff results between revisions, or feed the output into a bot that rewrites Markdown automatically.
• Clear exit codes — 0 means clean, 1 means findings, and 2 means failure. Those exit codes are exactly what CI systems and shell scripts need when you want a hard gate instead of a vague success message.
• Agent skill installation — npx slopless install-skill codex and npx slopless install-skill claude install the same skill body for agent workflows. That lets a writing agent run slopless, rewrite the text, and rerun the check without a human copying findings around.
• Fine-grained ignore blocks — intentional exceptions can be wrapped with textlint-disable and textlint-enable comments around the rule name. That is better than blanket suppression because you can document why a specific sentence is allowed to remain odd.
• Flexible input modes — slopless accepts a file path, glob, or stdin, which covers the common cases for docs repos and generated content. A bare npx slopless exits with code 2, so there is no ambiguity about missing input.
• English-only enforcement — the tool explicitly targets English Markdown, which keeps the rule set focused and reduces false positives from multilingual prose. That constraint is useful when your docs pipeline is already segmented by locale.

slopless vs Alternatives

Pick slopless when you want a terminal check that a writing agent can run repeatedly until the output is clean. It is a better fit than Claude Code Canvas for enforcement because Canvas is an editing surface, not a linter, and it pairs well with Claude Context Mode when the agent needs more document context before rewriting.

Pick Vale when your documentation team already maintains style vocabularies and wants broader editorial control across many repositories. Pick write-good when you only need a small set of readability heuristics, and pick proselint when you need generic prose checks without slopless's tighter Markdown-first, agent-aware workflow. If you are building a policy layer around content quality, DRYwall is a closer companion than a writing editor.

How slopless Works

slopless works as a thin Node.js CLI around deterministic textlint rules, so the document analysis happens locally and does not require network access to an LLM endpoint. The design is intentionally narrow: accept Markdown input, run rule families against the text, and emit machine-readable findings that downstream tooling can consume.

The important abstraction is the findings stream, not a conversational response. That makes slopless useful in automation because a CI job, shell script, or agent can inspect the JSON, make edits, and rerun the same command until the exit code flips to 0.

npm install -D slopless
npx slopless install-skill codex
npx slopless "docs/**/*.md" > .slopless/findings/review.json

The first command adds slopless to the repo, the second installs the agent skill, and the third runs a glob across Markdown files while saving the raw JSON artifact. In practice, this means a developer can check the output into a hidden findings directory, then let a bot or shell loop repair the prose incrementally.

slopless also supports inline rule suppression with textlint-disable comments, which is the right escape hatch for intentional fragments like quoted copy, product names, or unusual sentence fragments. That keeps the tool strict without making it unusable in real documentation, where not every line should read like a policy memo.

Pros and Cons of slopless

Pros:

• Deterministic output makes it easy to automate because the same Markdown produces the same JSON findings every run.
• No LLM dependency means no prompt drift, no inference cost, and no network call just to validate prose.
• Agent-friendly workflow supports Codex and Claude Code skills, which is ideal for rewrite-and-rerun loops.
• CI-ready exit codes map cleanly to shell scripts, GitHub Actions, and pre-merge gates.
• Markdown-first scope keeps the rule set focused on the format most docs teams actually ship.
• Inline suppression support gives teams a narrow escape hatch without disabling the whole checker.

Cons:

• English-only coverage blocks teams that need multilingual documentation checks.
• Rule-based judgment can miss nuanced tone issues that a human editor or model would catch.
• No hosted dashboard means you need your own storage if you want reporting or trend tracking.
• Limited to Markdown inputs so it is not a general prose QA system for every file type.
• Unknown release metadata on the page makes it harder to assess release cadence from the landing page alone.

Getting Started with slopless

The fastest way to start is to install slopless as a dev dependency, verify the CLI help, and run it against a Markdown glob. After that, wire the same command into CI or an agent loop so the output becomes part of your review process instead of a one-off manual check.

npm install -D slopless
npx slopless --help
npx slopless "docs/**/*.md"

After the first run, check the exit code and inspect the JSON findings for rule names, spans, and actionable messages. If you are using an agent workflow, install the Codex or Claude skill in the repo, start a fresh session, and tell the agent to keep rewriting until slopless returns a clean result.

For intentional exceptions, wrap the text in textlint-disable and textlint-enable comments around the exact rule name you want to suppress. That gives you a controlled exception path without turning off the rest of the lint pass.

Verdict

slopless is the strongest option for docs teams and agentic writing loops when you want deterministic Markdown enforcement without LLM variance. Its biggest strength is structured JSON output backed by 50+ rules, while the main caveat is English-only scope. Recommend it if you want a repeatable, CI-friendly slop check.