Hallmark's 58 Slop-Test Gates and Pre-Emit Self-Critique System Explained

Hallmark uses a rigorous 58-gate "slop-test" combined with a six-axis pre-emit self-critique to prevent AI-generated design repetition and enforce quality standards on every output page.

The slop-test gates are a comprehensive quality checklist defined in skills/hallmark/references/slop-test.md that every generated page must pass before completion. These gates, combined with a mandatory self-scoring step, form the core of Hallmark's defense against generic, templated output—what the project calls "slop."

What Are Hallmark's 58 Slop-Test Gates?

The 58 slop-test gates cover structural, visual, and semantic criteria that each page must satisfy. While the full list spans everything from contrast ratios to typography scale, Gate 8 (S8) stands out as the mechanism that prevents structural repetition across a project.

Gate 8: The Structural Uniqueness Check

Gate 8 specifically targets "structural reuse"—the tendency for AI-generated pages to follow identical macro-structures (e.g., "Hero → 3 features → CTA → footer") despite surface-level variations in color or typography.

The gate operates by:

• Checking .hallmark/log.json for the macro-structure used in previous builds
• Comparing against a CSS macro-structure stamp in the current output
• Failing the build if the current structure matches any previous one for the same project

This prevents "catalog-style" copies where palettes shift but layouts remain interchangeable. According to the source in skills/hallmark/references/slop-test.md, Gate 8 "guarantees that a new page does not repeat the same macro-structure or the generic AI template."

How the Pre-Emit Self-Critique System Works

Before any slop-test gate runs, Hallmark requires a pre-emit self-critique—a six-axis scoring evaluation applied to the planned output. Each axis receives a score from 1 to 5; any score below 3 triggers a mandatory revision pass.

The Six Axes (A–F)

Axis	Name	Evaluation Criterion
A	Philosophy	Is there a clear "why" behind the page?
B	Hierarchy	Is visual hierarchy obvious within 2 seconds?
C	Execution	Are details (rule weight, accent footprint, contrast) precise?
D	Specificity	Does the design feel tailored to the brief, not generic?
E	Restraint	Have all unnecessary decorations been removed?
F	Variety	Does output differ structurally from previous Hallmark pages?

The scores are recorded in a standard one-line comment at the top of each generated file:

/* Hallmark · pre-emit critique: P5 H4 E5 S4 R5 V5 */

Only after all six scores reach 3 or higher does Hallmark proceed to the 58-gate slop-test.

Implementing the Self-Critique and Gate 8

Adding the Pre-Emit Critique Comment

Generated CSS files must include the critique signature before any other content:

/* Hallmark · pre-emit critique: P5 H5 E5 S5 R5 V5 */
:root {
  --color-accent: var(--color-blue-5);
  --font-display: "Inter", system-ui;
}
/* ... remaining stylesheet ... */

Checking Gate 8 Programmatically

A build step might implement Gate 8 verification as follows:

const fs = require('fs');
const path = './.hallmark/log.json';

const cssStamp = fs.readFileSync('styles.css', 'utf8')
                   .match(/\/\* Hallmark · macrostructure: (\w+) \*\//)?.[1];

const lastLog = JSON.parse(fs.readFileSync(path, 'utf8'));
const lastMacro = lastLog?.macrostructure;

if (cssStamp && cssStamp === lastMacro) {
  throw new Error('Gate 8 failed: macrostructure repeats previous build');
}
// Proceed with build

Self-Critique Scoring Helper

A simple interactive scorer for the six axes:

const axes = ['Philosophy', 'Hierarchy', 'Execution', 'Specificity', 'Restraint', 'Variety'];
const scores = axes.map(ax => prompt(`Score ${ax} (1-5):`));

if (scores.some(s => s < 3)) {
  console.log('Revision required before proceeding.');
} else {
  console.log('Self-critique passed—proceeding to 58-gate slop-test.');
}

Key Source Files in Hallmark

File Path	Purpose
skills/hallmark/references/slop-test.md	Defines all 58 slop-test gates including Gate 8 and pre-emit self-critique
skills/hallmark/SKILL.md	References the self-critique and links to slop-test documentation
README.md	Outlines Hallmark's full workflow: macrostructure → theme → self-critique → slop-test

Summary

• Hallmark's 58 slop-test gates enforce comprehensive quality standards on every generated page.

• Gate 8 (S8) specifically prevents structural repetition by comparing macro-structures against .hallmark/log.json history.

• The pre-emit self-critique scores planned output on six axes (Philosophy, Hierarchy, Execution, Specificity, Restraint, Variety) with mandatory revision for any score below 3.

• Scores are embedded as /* Hallmark · pre-emit critique: P# H# E# S# R# V# */ comments in generated files.

• Only after passing self-critique does Hallmark execute the full 58-gate slop-test.

Frequently Asked Questions

What happens if a page fails Gate 8?

The build halts with an error and the page must be rebuilt using a different macro-structure. The new structure must then pass both the self-critique and all 58 slop-test gates.

Can the self-critique axes be customized?

No—the six axes (A–F) are fixed in skills/hallmark/references/slop-test.md as part of Hallmark's core methodology. The scoring scale of 1–5 with a minimum threshold of 3 is also standardized.

Where is the macro-structure history stored?

Hallmark maintains a log at .hallmark/log.json that tracks macro-structures used in previous builds for each project, enabling Gate 8 to detect repetition.

Is the pre-emit critique comment required in all file types?

Yes—any generated output file must include the critique comment as its first line, using the standard format /* Hallmark · pre-emit critique: P# H# E# S# R# V# */.

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