The Anti-Slop Linter for Your Coding Agent

📖 Read the full version with charts and embedded sources on AgentConn →

Nutlope/hallmark runs 58 deterministic anti-slop gates on every AI-generated page before it ships. It is an open-source design skill for Claude Code, Cursor, and Codex with 5.3k GitHub stars and a single install command: npx skills add nutlope/hallmark. The tool caught the wave at the right moment — the same week it was trending on GitHub, Zig creator Andrew Kelley's anti-AI-code stance hit 1,430 points on Hacker News with 719 comments. The thesis that scored highest: "The value lives in battle-testing, not code volume."

The community has stopped debating whether AI can write code. It can. The new question is whether anyone should trust what it wrote without a quality gate standing between generation and production.

View original post on X →

This article breaks down what Hallmark actually catches, how tools like sloppylint and Claude Code Review extend the same principle to backend code, and why bolting a deterministic quality gate onto your agent loop is the highest-leverage move a team can make right now.

---

The Slop Problem in Numbers

The data is no longer anecdotal. Faros AI analyzed production workflows and found that AI generates roughly 4x more code output but delivers only about 12 percent additional value. Review duration increased 441.5 percent. Code churn rose 861 percent. Defect rates climbed from 9 percent to 54 percent per developer.

View original post on X →

CodeRabbit's December 2025 analysis confirmed the pattern: AI-written code produces 1.7x more issues than human-authored code. Logic and correctness problems spiked 75 percent. Security issues appeared 1.5 to 2x more frequently. And the scariest number from Faros: PRs merged with zero review increased 31.3 percent.

⚠️ The productivity trap: Teams generating 25-35% more code with AI see 91% longer PR review times. The generation speed gain is eaten by downstream review cost. You are not shipping faster. You are shipping more code into a queue that grows faster than it drains.

Andrew Kelley, creator of Zig, takes the hardline position. He calls AI-generated contributions "invariably garbage" with "negative value" because they consume limited reviewer capacity without delivering commensurate quality. The Zig project bans all LLM-assisted editing, brainstorming, and debugging from contributions — not just fully generated code.

View on Hacker News →

His reasoning is harder to dismiss than most critics expect. In the HN thread, commenter sph articulated what many senior engineers feel: projects generated quickly lack emotional investment. The sunk cost fallacy becomes a feature when developers persevere through difficulties because they have invested substantial effort — a dynamic absent when LLMs produce quick proofs-of-concept requiring minimal human commitment.

But most teams are not going to ban AI code. They have already adopted it. The pragmatic question is: what quality gate do you put between the agent and production?

---

What Hallmark Actually Catches

Hallmark is not a traditional linter. It is a design skill — a set of instructions that load into your coding agent and enforce rules before the agent emits its output. Created by Hassan El Mghari (@nutlope) and backed by Together AI, it targets the specific aesthetic and structural patterns that mark AI-generated frontends.

The skill runs four verbs: Build generates new UI with enforced structural variety. Audit scores existing code against anti-patterns. Redesign rebuilds the visual layer while preserving content. Study extracts design DNA from screenshots or URLs.

The 58 slop-test gates run after every build. Here is what they check:

Typography tells:

• Italic emphasis inside headings — one of the most reliable AI tells
• All-italic display faces
• Section tags hard-left with heading right (the hanging-header pattern)
• Buttons and CTAs using font-style: italic

Visual tells:

• The "specimen fall-through" — the same hero, three-feature grid, CTA, footer rhythm that every AI build defaults to
• Invented metrics without real user data
• Re-drawn UI chrome (fake browser bars, code-block windows that no real product would render)
• Mid-render token improvisation: inline hex values instead of named CSS custom properties

Layout tells:

• Horizontal scroll on mobile at 320, 375, 414, and 768px breakpoints
• Two-line clickable text on buttons and nav links
• Image grids using bare 1fr instead of minmax(0, 1fr)

Interaction tells:

• Missing interactive states — every component must ship default, hover, focus, active, disabled, loading, error, and success states
• Animation of layout properties instead of using only transform and opacity
• Focus rings that animate instead of appearing instantly
• Ignoring prefers-reduced-motion: reduce

The diversification rule is what separates Hallmark from a static checklist. No two consecutive builds can share the same macrostructure. Themes must differ on at least one axis: paper band (dark, mid, or light), display style (serif, sans, or mono), or accent hue (warm, cool, or neutral). The skill maintains a .hallmark/log.json file that tracks previous builds and enforces rotation across 20 named themes: Specimen, Atelier, Brutal, Newsprint, Studio, Manifesto, Terminal, Midnight, Almanac, Garden, Riso, Sport, Bloom, Coral, Cobalt, Aurora, Editorial, Carnival, Lumen, and Hum.

This matters because the deepest form of AI slop is not any single bad pattern — it is structural monotony. Two different briefs producing layouts that look like color swaps of the same template is the tell that breaks user trust faster than any misaligned heading.

💡 How to install: Run npx skills add nutlope/hallmark in any project. The skill loads into your agent's context automatically. To audit an existing project: hallmark audit ./src/components/landing-page.tsx. The audit verb scores your code against all 58 anti-patterns and returns a ranked punch-list without making edits.

---

Beyond Design: Code-Level Anti-Slop Tools

Hallmark addresses the frontend. But the same principle applies to backend and infrastructure code, where the slop patterns are different but equally recognizable.

Sloppylint (GitHub) targets AI-generated Python specifically. It catches 100+ patterns including:

• Hallucinated imports — 20 percent of AI-generated imports reference packages that do not exist
• Wrong-language patterns bleeding into Python: .push(), .equals(), .forEach()
• Placeholder code: bare pass statements, ... bodies, orphaned TODO comments
• Mutable default arguments and bare exception handlers that human Python developers would catch instinctively but AI misses consistently

The tool installs with pip install sloppylint and runs as a standalone CLI. It is not a replacement for traditional linters — it catches the specific mistakes AI makes that humans would not.

Claude Code Review takes a different approach entirely. When a PR opens, Claude dispatches a team of agents to hunt for bugs. Anthropic reports under 1 percent incorrect findings and substantive review rates jumping from 16 percent to 54 percent. The key insight from Addy Osmani's analysis: running four independent reviewers in parallel found that 93.4 percent of flagged locations were caught by exactly one tool with no line flagged by all four. Heterogeneous review outperforms any single-tool strategy.

View original post on X →

📊 The review inversion: When agents write the code, review inverts. You stop asking "is this correct?" and start asking "was the intent clear enough to execute safely?" The skill that matters most in 2026 is not writing code — it is judging whether AI-written code should ship.

---

Wiring a Quality Gate Into Your Agent Loop

Here is the practical setup for three levels of anti-slop protection, from quick win to full pipeline.

Level 1: Install Hallmark (5 minutes)

For any project using Claude Code, Cursor, or Codex:

npx skills add nutlope/hallmark

That is it. The skill loads into your agent's context. Every UI generation now runs through the 58-gate slop test before the agent hands output back to you.

To audit an existing project:

hallmark audit ./src/components/landing-page.tsx

Level 2: Add Code-Level Linting (15 minutes)

For Python projects, add sloppylint to your pre-commit hooks:

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: sloppylint
        name: sloppylint
        entry: sloppylint
        language: python
        types: [python]

For TypeScript and JavaScript projects, tools like aislop provide similar coverage with 50+ rules across 8 languages. The install is the same pattern — add it to your existing lint chain so it runs on every commit.

Level 3: Multi-Agent Review Pipeline (30 minutes)

The most robust approach combines automated linting with AI-powered review. The pattern works with any CI system:

# .github/workflows/anti-slop.yml
name: Anti-Slop Gate
on: [pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run sloppylint
        run: pip install sloppylint && sloppylint ./src/
      - name: Run standard linters
        run: npm run lint && npm run typecheck

  ai-review:
    runs-on: ubuntu-latest
    steps:
      - name: Claude Code Review
        uses: anthropic/claude-code-review@v1
        with:
          threshold: medium

The key insight from Zencoder's research: plan review matters more than code review for AI-written code. By the time a flawed agent plan becomes a polished diff, the costly error has already occurred. The ideal pipeline gates at three points:

1. Pre-generation: The agent's plan is reviewed before it writes code — CLAUDE.md constraints, Hallmark's brief-stage questions, and agent-level guardrails
2. Post-generation: Deterministic linters catch known AI patterns — sloppylint, aislop, Hallmark's 58 gates
3. Pre-merge: Multi-agent review catches semantic and architectural issues — Claude Code Review, CodeRabbit, Qodo

---

What the Community Is Saying

The Hacker News thread on Zig's Andrew Kelley drew 719 comments and crystallized the divide. On one side, purists who agree with Kelley that AI code is inherently unreviewable. On the other, pragmatists who argue the genie is out of the bottle and the only question is how to build better filters.

TeriyakiBomb summarized the pragmatist case in the thread: rapid AI-assisted development produces "vibe coded" projects with "feature bloat" and unpolished core functionality. The lack of iteration time lets bad design decisions ship unchallenged. RetroTechie made the stronger point: existing codebases have undergone real-world stress testing, and a fresh rewrite starts at zero regardless of how fast it was produced.

View original post on X →

Raul Junco's framing cuts even sharper: "The same AI that wrote your code is now reviewing it. Same model. Same training data. Same blind spots. That is not code review. That is how you get AI slop." His point matters because many teams assume that running an LLM over its own output catches errors. It does not — the same biases that produced the slop are the same biases that miss it in review.

This is exactly why deterministic gates matter. A linter does not share the model's training distribution. It does not hallucinate. It does not get tired. It checks the same 58 patterns every time with zero variance. The LLM is the creative engine; the linter is the quality floor.

⚡ The contrarian take: If your agent's output needs 58 gates to not look like garbage, maybe the model itself is the bottleneck. Andrew Kelley would say so. But for teams already shipping with AI assistance, a deterministic quality gate is the pragmatic middle ground between "ban everything" and "ship everything." The question is not whether to use AI. It is whether you have the discipline to review what it produces.

---

What This Means for You

The pattern is clear across the entire 2026 tool ecosystem: the review layer is the product now. The model that generates code is becoming a commodity. The gate that decides whether that code ships is where the value concentrates.

Three concrete takeaways:

1. Install a deterministic gate today. Whether it is Hallmark for frontend, sloppylint for Python, or aislop for multi-language projects, the install is under 5 minutes and the ROI is immediate. You will catch patterns you have been manually flagging in review.

2. Separate generation from review. The worst anti-pattern in agent-assisted development is using the same model to write and review. Heterogeneous review — multiple tools with different architectures catching different patterns — outperforms any single reviewer by a wide margin. Addy Osmani's data shows 93.4 percent of issues are caught by exactly one tool.

3. Gate at the plan, not just the diff. The most expensive bugs in AI-generated code are not syntax errors. They are strategic mistakes: patching symptoms instead of root causes, crossing architectural boundaries, adding tests that validate broken behavior. The earlier your gate runs, the cheaper the catch.

The teams that will ship reliably in 2026 are not the ones with the best models. They are the ones with the best review pipelines. Hallmark, sloppylint, and multi-agent code review are not luxuries — they are the minimum viable quality stack for any team that uses AI to write code.

For more on building robust agent pipelines, see our breakdown of why 90% of AI agents die after the demo and the code quality bottleneck that 10x PRs create.

Originally published at AgentConn