What Are the 58 Slop-Test Gates in Hallmark and How Do They Work?

The 58 slop-test gates in Hallmark comprise a comprehensive anti-template verification system that prevents AI-generated pages from exhibiting repetitive structural patterns, with the S8 gates (8 and 9) serving as the structural-fingerprint layer that enforces macrostructure uniqueness through CSS stamp comparison and automatic layout variation.

The Nutlope/hallmark repository implements 58 slop-test gates defined in skills/hallmark/references/slop-test.md to eliminate "template drift" in generated pages. While the full suite covers diverse anti-slop checks, gates 8 and 9—collectively designated as the S8 structural-fingerprint layer—form the critical defense against macrostructure duplication and monotone section spacing. These gates analyze CSS stamps and project history to ensure every Hallmark page maintains genuine visual distinctiveness.

The S8 Gates Within the 58-Gate Architecture

Among the 58 slop-test gates that guard against AI-generated tells, the S8 gates specifically target structural fingerprinting. According to the Hallmark source code, these two gates prevent the "generic AI skeleton" (Hero → 3-features → CTA → footer) from repeating across pages in the same project. When Hallmark finishes building a page, it prepends a CSS stamp comment to the stylesheet and compares it against the project history stored in .hallmark/log.json.

Gate 8: The Structural-Fingerprint Gate

What It Checks

Gate 8 validates that the current page does not reuse the exact same macrostructure as any previous Hallmark output in the same project. This includes detecting the generic AI skeleton or identical layouts like "Bento-Grid + Feature-Cards" without variation. The gate inspects the CSS stamp comment (e.g., /* Hallmark · macrostructure: bento-grid · tiles=6, spans=irregular, accent=corner-only */) to extract the archetype name and knob settings.

Why It Matters

Re-using identical macrostructures across multiple pages creates the "color-swap of a template" effect—a classic indicator of AI-generated content. Gate 8 forces Hallmark to emit a different macrostructure for every new page, ensuring genuine visual variety and preventing template drift.

Enforcement Mechanism

At build time, Hallmark executes the following verification sequence:

1. Stamp Extraction – Reads the current CSS stamp and the previous stamp from .hallmark/log.json (or the prior CSS file).
2. Comparison Logic – Fails if the macrostructure name is identical and no knob (tiles, spans, accent, etc.) differs between builds.
3. Automatic Remediation – Upon failure, Hallmark selects a different archetype from the component catalogue (e.g., switching from bento-grid to stat-led) or varies a knob (e.g., changing tiles=6 to tiles=8) before re-emitting the page.

Gate 9: The Uniform-Section Gate

Visual Separation Detection

Gate 9 checks whether page sections are separated only by equal whitespace without visual cues such as rule lines, ornaments, or color shifts. A page that slides from one block to the next with no visual break feels "templated" and loses hierarchy.

Automatic Visual Rhythm Injection

If Hallmark detects no section-separator rules (like border-top or background-color changes), the gate fails and Hallmark automatically injects a subtle rhythm. This typically involves adding a lightweight visual separator such as border-top: 1px solid var(--color-divider) or a subtle background-tint to create necessary visual distinction between sections.

The Five-Step Slop-Test Verification Process

When Hallmark generates a page, the S8 gates operate through a strict five-step workflow:

1. Pre-emit Stamp Creation – Hallmark prepends a structured comment to the CSS: /* Hallmark · macrostructure: [type] · [knobs] */.
2. Log Lookup – The system reads /.hallmark/log.json to discover the macrostructure of the last Hallmark page in the project.
3. Comparison – Gate 8 flags a failure if the macrostructure name and all knobs match exactly; Gate 9 flags if only identical whitespace separates sections.
4. Automatic Remediation – Hallmark varies the layout archetype or adds visual separators.
5. Re-run – Hallmark reruns the full slop-test (58 gates) until the S8 gates report "no" and the page is ship-ready.

Manual Testing Code Examples

The following snippets illustrate how to manually check the S8 gates for debugging or custom tooling:

// Example: Detecting gate 8 in a Node script
const fs = require('fs');
const path = require('path');

function readStamp(cssPath) {
  const content = fs.readFileSync(cssPath, 'utf8');
  const stamp = content.match(/Hallmark · macrostructure: (\S+) · (.+?)\n/);
  if (!stamp) return null;
  return { name: stamp[1], knobs: stamp[2] };
}

function isSameStructure(prev, cur) {
  if (!prev || !cur) return false;
  if (prev.name !== cur.name) return false;
  // Simple knob diff – split on commas and trim
  const prevKnobs = new Set(prev.knobs.split(',').map(s => s.trim()));
  const curKnobs  = new Set(cur.knobs.split(',').map(s => s.trim()));
  // Fail only if every knob is identical
  for (const k of prevKnobs) if (!curKnobs.has(k)) return false;
  return true;
}

// Paths – adjust to your repo layout
const prevCss = path.join('site', 'prev-page.css');
const curCss  = path.join('site', 'next-page.css');

const prevStamp = readStamp(prevCss);
const curStamp  = readStamp(curCss);

if (isSameStructure(prevStamp, curStamp)) {
  console.error('🚨 S8‑gate 8 failure: macrostructure duplicated without knob change');
}

/* Example: Adding a section separator to satisfy gate 9 */
.section {
  padding-block: var(--space-m);
}
.section + .section {
  border-top: 1px solid var(--color-divider); /* visual break → passes gate 9 */
}

Key Configuration Files

The S8 gates rely on specific reference and runtime files:

• skills/hallmark/references/slop-test.md – Contains the master list of all 58 gates, including the definitions for gate 8 (Structural-fingerprint) and gate 9 (Uniform-section).
• skills/hallmark/references/structure.md – Describes allowed macrostructures and acceptable visual separators for section breaks.
• skills/hallmark/SKILL.md – The high-level skill definition that triggers the slop-test after build and manages the stamp recording process.
• .hallmark/log.json – Generated at runtime in the project root; persists the macrostructure stamp of the last Hallmark run for comparison against new builds.

Summary

• The 58 slop-test gates in Hallmark prevent AI-generated template drift, with gates 8 and 9 forming the structural-fingerprint layer.
• Gate 8 enforces macrostructure uniqueness by comparing CSS stamps against .hallmark/log.json and requiring knob variations when reusing archetypes.
• Gate 9 ensures sections have visual separators rather than uniform whitespace, injecting borders or background-tints when necessary.
• Hallmark automatically remediates failures by selecting different archetypes, varying knobs, or adding visual rhythm until all 58 gates pass.

Frequently Asked Questions

What is the difference between gate 8 and gate 9 in the S8 layer?

Gate 8 checks for macrostructure duplication (reusing identical layout archetypes like bento-grids without knob variations), while gate 9 checks for uniform section spacing (sections separated only by whitespace without visual cues). Gate 8 operates by comparing CSS stamps in log.json, whereas gate 9 inspects CSS for separator rules like borders or background-color shifts.

How does Hallmark store previous macrostructure data for comparison?

Hallmark writes a CSS stamp comment to the top of each generated stylesheet (e.g., /* Hallmark · macrostructure: bento-grid · tiles=6... */) and persists this data in .hallmark/log.json at the project root. At build time, the S8 gates read this runtime log to compare the current page's structure against the previous output.

What happens when a page fails the structural-fingerprint gate?

When gate 8 detects an identical macrostructure without knob changes, Hallmark automatically remediates by either selecting a different archetype from the component catalogue (such as switching from bento-grid to stat-led) or varying specific knobs (like changing tile counts or accent placements). It then re-emits the page and re-runs the full 58-gate test suite.

Do all 58 gates focus on structural patterns like gates 8 and 9?

No, the 58 gates cover diverse anti-slop checks beyond structural fingerprinting. While gates 8 and 9 specifically target macrostructure and visual section separation, other gates in slop-test.md address different AI-generated tells such as repetitive phrasing, generic stock imagery patterns, or inconsistent spacing systems.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}