# How the Hallmark Slop Test Works: A 58-Gate Anti-AI-Slop Checklist

> Discover how the Hallmark Slop Test works. This 58-gate system validates pages against anti-AI sloppiness rules, automatically revising content to ensure quality.

- Repository: [Hassan El Mghari/hallmark](https://github.com/Nutlope/hallmark)
- Tags: how-to-guide
- Published: 2026-07-16

---

**The Hallmark Slop Test is a deterministic 58-gate validation system that checks every generated page against anti-AI-sloppiness design rules, forcing automatic revisions if any gate fails.**

The Hallmark Slop Test serves as the quality assurance backbone of the Hallmark framework (Nutlope/hallmark), ensuring every generated web page meets strict non-sloppy standards before shipping. This deterministic checklist operates as a mandatory gate in the build pipeline, preventing common AI-generated design pitfalls through automated enforcement.

## What Is the Hallmark Slop Test?

The Hallmark Slop Test is a comprehensive validation system defined in [`/skills/hallmark/references/slop-test.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/references/slop-test.md) that guarantees every generated page obeys anti-AI-sloppiness design rules. Unlike subjective aesthetic review, this test operates as a deterministic 58-gate checklist where every gate must return "no" to pass validation.

### The 58-Gate Deterministic Checklist

After the page is built, Hallmark reads the slop-test file and answers "yes" or "no" to each of the 58 gates. All gates must return **no**; any "yes" marks the output as *slop* and forces a fix before the build can ship, as documented in `/skills/hallmark/references/slop-test.md#L27-L70`.

The gates cover visual, structural, micro-interaction, variety, implementation, hero-enrichment, diversification, and layout-safety criteria. For example:

- **Gate 10**: No `transition-all` declarations (`/skills/hallmark/references/slop-test.md#L45-L46`)
- **Gate 34**: No horizontal scroll at any breakpoint (`/skills/hallmark/references/slop-test.md#L90-L92`)
- **Gate 37**: No more than three font families (`/skills/hallmark/references/slop-test.md#L96-L99`)

### Pre-Emit Self-Critique Scoring

Before any HTML or CSS is emitted, Hallmark scores the design on six axes: **Philosophy, Hierarchy, Execution, Specificity, Restraint, and Variety**. Any axis scoring below 3 triggers an automatic revision pass. These scores are recorded in a stamp comment at the top of the output file, following the format shown in `/skills/hallmark/references/slop-test.md#L9-L24`:

```css
/* Hallmark · pre‑emit critique: P5 H4 E5 S4 R5 V5 */

```

## How the Slop Test Integrates Into the Build Pipeline

According to [`/skills/hallmark/SKILL.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/SKILL.md), the slop test is embedded directly into the Hallmark workflow as a mandatory validation step that blocks deployment until satisfied.

### Step-wise Workflow Execution

The [`SKILL.md`](https://github.com/Nutlope/hallmark/blob/main/SKILL.md) file defines a precise process where the slop test runs immediately after the build phase:

1. **Step 6**: Build phase completes
2. **Step 7**: Slop test execution (`/skills/hallmark/SKILL.md#L430-L444`)

The result is written into the preview block as either `Slop test: 58/58 ✓` or a list of failing gate numbers. If any gate fails, the builder returns to the relevant step, corrects the issue, and re-runs the test until all 58 gates pass.

### Genre-Scoped Overrides

Some gates are universal, while others apply only to specific genres: **editorial, atmospheric, modern-minimal, and playful**. The slop-test file contains inline notes indicating which gates are relaxed for each genre. For instance, gradient text is always forbidden, but atmospheric pages may keep radial-gradient backgrounds (`/skills/hallmark/references/slop-test.md#L30-L33` and `/skills/hallmark/references/slop-test.md#L36-L38`).

## Key Enforcement Points and Anti-Patterns

The slop test enforces specific constraints defined across multiple reference files in the Hallmark repository.

### Visual and Structural Gates

Beyond the font family and transition limits, the test enforces layout safety constraints such as:

- **Gate 34**: Prohibiting horizontal scroll at any viewport breakpoint
- **Gate 10**: Banning `transition-all` declarations that cause performance issues

### Content Integrity Checks

The slop test cross-references [`/skills/hallmark/references/anti-patterns.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/references/anti-patterns.md) to catch content-level slop:

- **Gate 46**: No invented metrics or fake statistics
- **Gate 54**: No placeholder names or generic filler text (`/skills/hallmark/references/anti-patterns.md#L215-L219`)

## Code Implementation Examples

The following examples demonstrate how the slop test logic is implemented in the Hallmark pipeline.

**Running the validation loop:**

```javascript
function runSlopTest(buildResult) {
  const gates = loadSlopGates();               // loads slop-test.md
  const failures = [];
  for (const gate of gates) {
    if (gate.appliesToGenre && !gate.matchesGenre(activeGenre)) continue;
    if (gate.check(buildResult)) failures.push(gate.id);
  }
  return failures;
}

```

**Checking font family limits (Gate 37):**

```javascript
function checkFontFamilies(css) {
  const families = new Set();
  css.match(/font-family:\s*([^;]+);/g).forEach(decl => {
    families.add(decl.split(':')[1].trim());
  });
  return families.size > 3; // true = slop detected
}

```

**Updating the preview block:**

```html
<!-- Successful run -->
<div class="preview">
  <p>Slop test: 58/58 ✓</p>
</div>

<!-- Failed run -->
<div class="preview">
  <p>Slop test: 52/58 – fails: 10, 23</p>
</div>

```

## Summary

- The **Hallmark Slop Test** is a deterministic 58-gate checklist that prevents AI-generated design slop from shipping to production.
- It operates through a **pre-emit self-critique** scoring six axes (Philosophy, Hierarchy, Execution, Specificity, Restraint, Variety) and a **post-build gate validation** that must return all "no" responses.
- The test runs at **Step 7** of the Hallmark workflow, immediately following the build phase, and blocks deployment until all gates pass.
- **Genre-scoped overrides** allow specific relaxations for editorial, atmospheric, modern-minimal, and playful styles while maintaining universal prohibitions.
- Failed gates force immediate iteration, with results displayed in the preview block showing either `58/58 ✓` or specific failing gate numbers.

## Frequently Asked Questions

### What happens if a gate fails the Hallmark Slop Test?

If any gate returns "yes" (indicating slop detected), the build is marked as failed and cannot ship. The system returns to the relevant workflow step to correct the issue, then re-runs the test. The preview block displays the specific failing gate numbers (e.g., `Slop test: 52/58 – fails: 10, 23`) to guide the correction process.

### How does the pre-emit critique scoring work?

Before generating HTML or CSS, Hallmark evaluates the design across six axes: Philosophy, Hierarchy, Execution, Specificity, Restraint, and Variety. Each axis receives a score from 1-5. If any axis scores below 3, the system triggers an automatic revision pass. The scores are recorded in a stamp comment at the top of the output file using the format `P# H# E# S# R# V#`.

### Are all 58 gates applied to every genre?

No. While many gates are universal, some apply only to specific genres: editorial, atmospheric, modern-minimal, or playful. According to [`/skills/hallmark/references/slop-test.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/references/slop-test.md), certain constraints like gradient text are universally forbidden, while radial-gradient backgrounds may be permitted for atmospheric pages. The test checks `gate.appliesToGenre` before evaluating genre-specific rules.

### Where is the Hallmark Slop Test defined in the codebase?

The canonical 58-gate list resides in [`/skills/hallmark/references/slop-test.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/references/slop-test.md), which defines each gate and the pre-emit critique methodology. The workflow integration is specified in [`/skills/hallmark/SKILL.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/SKILL.md) at lines 430-444, while specific anti-patterns like invented metrics are documented in [`/skills/hallmark/references/anti-patterns.md`](https://github.com/Nutlope/hallmark/blob/main//skills/hallmark/references/anti-patterns.md). The user-facing documentation references the test in [`/site/js/main.js`](https://github.com/Nutlope/hallmark/blob/main//site/js/main.js).