Hallmark's 58 Slop-Test Gates and Pre-Emit Self-Critique: Complete Technical Guide

Hallmark enforces a rigorous 58-gate slop-test checklist combined with a six-axis pre-emit self-critique to eliminate structural repetition and enforce design quality standards before any output is finalized.

The open-source Hallmark framework (Nutlope/hallmark) implements a strict quality assurance protocol that every generated page must pass. At the core of this system are 58 distinct validation gates—collectively known as the slop-test—and a mandatory pre-emit self-critique that scores planned outputs across six critical dimensions before they ever reach the build stage.

The 58 Slop-Test Gates Explained

What Are the Slop-Test Gates?

According to skills/hallmark/references/slop-test.md, the slop-test is a comprehensive checklist of 58 "gates" that each generated page must pass before Hallmark considers the build finished. These gates validate everything from structural integrity to visual specificity, ensuring AI-generated outputs meet strict quality benchmarks rather than defaulting to generic templates.

Gate 8 (S8): Structural Reuse Prevention

Gate 8 specifically targets macro-structure duplication, preventing "catalog-style" copies where only color palettes change but the overall layout remains identical. This gate guarantees that new pages do not repeat the same macro-structure or generic AI template (e.g., "Hero → 3 features → CTA → footer") used in previous Hallmark outputs for the same project.

The validation mechanism checks for a log entry in .hallmark/log.json or a CSS macro-structure stamp within the generated stylesheet. If the current build's macro-structure matches the previous build recorded in the log, Gate 8 fails and the system requires a rebuild with a different architectural approach. This ensures each page in a project maintains distinct structural identity.

How the Pre-Emit Self-Critique Functions

The Six Quality Axes (A-F)

Before the 58 slop-test gates execute, Hallmark initiates a pre-emit self-critique that scores the planned output across six axes, each rated on a 1–5 scale:

• A – Philosophy: Does the page have a clear "why" or purpose driving its design?
• B – Hierarchy: Is the visual hierarchy obvious within 2 seconds of viewing?
• C – Execution: Are the details (rule weight, accent footprint, contrast ratios) correct and precise?
• D – Specificity: Does the design feel tailored to the specific brief rather than generic?
• E – Restraint: Have all unnecessary decorative elements been removed?
• F – Variety: Does the output differ structurally from previous Hallmark pages in the same project?

Scoring Thresholds and Enforcement

Any axis scoring below 3 forces an immediate revision pass. The author must revisit the design, adjust the weak areas, and re-run the self-critique until all six scores reach at least 3. Only after achieving a successful self-critique does Hallmark proceed to the full 58-gate slop-test.

Scores are recorded in a standardized one-line comment placed at the very top of the generated file. As documented in skills/hallmark/SKILL.md, the format uses letter codes corresponding to each axis:

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

Implementation and Code Examples

To add the required pre-emit critique comment to a generated CSS file:

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

The following JavaScript pseudo-code demonstrates how Gate 8 programmatically checks for macro-structure reuse against the project log:

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');
}
// else continue building

For implementing the self-critique scoring interface:

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.');
}

Summary

• Hallmark validates every output against 58 slop-test gates defined in skills/hallmark/references/slop-test.md.
• Gate 8 (S8) prevents structural reuse by comparing current macro-structures against .hallmark/log.json and CSS stamps.
• The pre-emit self-critique scores designs on six axes (Philosophy, Hierarchy, Execution, Specificity, Restraint, Variety) using a 1–5 scale.
• Any score below 3 triggers mandatory revision before the slop-test executes.
• Final scores are embedded as comments in generated files using the format /* Hallmark · pre‑emit critique: ... */.

Frequently Asked Questions

What happens if a page fails Gate 8 during the slop-test?

If Gate 8 detects that the current macro-structure matches a previous build recorded in .hallmark/log.json, the build aborts immediately. The system throws an error requiring the author to rebuild the page with a different structural template, preventing repetitive "catalog-style" layouts across the project.

How does the pre-emit self-critique scoring system work?

The self-critique evaluates planned outputs across six axes—Philosophy, Hierarchy, Execution, Specificity, Restraint, and Variety—each rated from 1 to 5. According to the implementation in skills/hallmark/references/slop-test.md, any axis scoring below 3 forces a revision loop. The process repeats until all scores meet or exceed 3, at which point the 58-gate slop-test begins.

Where are the 58 slop-test gates documented?

The complete list of 58 gates, including detailed specifications for Gate 8 and the pre-emit self-critique protocol, is located in skills/hallmark/references/slop-test.md. Additional context appears in skills/hallmark/SKILL.md and the project's README.md, which describes the workflow progression from macrostructure to theme to final quality validation.

Can the pre-emit critique comment be modified or omitted?

The comment format /* Hallmark · pre‑emit critique: [scores] */ is standardized and expected by the build system. As implemented in the Hallmark source, this comment must appear at the top of generated files to verify that the self-critique phase completed successfully before the slop-test gates are evaluated.

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