Validation Steps in the No AI Slop Build Process: A Complete Technical Guide

The No AI Slop build process runs two sequential validation phases—source validation via validate_source() and build-artifact validation via validate_build()—to ensure every plugin package is complete, consistent, and ready for distribution.

The petergyang/no-ai-slop repository uses a Python-based build pipeline to package plugins for distribution. Understanding the validation steps in the No AI Slop build process ensures developers catch schema errors, missing assets, and packaging inconsistencies before deployment.

Overview of the Build and Validation Pipeline

The build_plugin.py script orchestrates the entire build-and-validation pipeline. Located at scripts/build_plugin.py, this utility performs strict validation at two distinct checkpoints before finalizing the distributable ZIP archive. The pipeline aborts immediately via SystemExit if any validation check fails, preventing corrupted or incomplete packages from reaching users.

Developers can run validation without keeping build artifacts by using the --check flag. This mode executes both validation phases against a temporary build directory that is automatically removed after verification succeeds.

Phase 1: Source Validation (validate_source)

The first checkpoint, implemented in validate_source() at lines 25‑48, scrutinizes the plugin manifest and required assets before any packaging occurs.

Manifest Schema Verification

The validation enforces the presence of all required top-level fields in .codex-plugin/plugin.json:

• name, version, description, author, skills, and interface

Within the interface object, every sub-field must be populated:

• displayName, shortDescription, longDescription, developerName, category, capabilities, and defaultPrompt

Prompt Constraints and Asset Verification

The defaultPrompt list must contain ≤ 3 entries, and each entry must be ≤ 128 characters. This constraint prevents oversized prompt contexts that could impact plugin performance.

Additionally, validate_source() verifies the existence of essential source assets on disk:

• skills/no-ai-slop/SKILL.md (core rule set)
• skills/no-ai-slop/eval.md (evaluation checklist)
• assets/no-ai-slop.png (visual icon)

If any required file is missing or any manifest field violates the schema constraints, the script terminates with a descriptive error message.

Phase 2: Build-Artifact Validation (validate_build)

Once source validation passes and the ZIP archive is created, the second checkpoint—validate_build() at lines 82‑99—examines the final build artifact.

Archive Integrity Checks

This phase performs three critical verifications:

1. File Manifest Check: The archived plugin must contain exactly the expected set of files:

   • plugin.json
   • PNG icon file
   • SKILL.md
   • eval.md
   • LICENSE
   • PRIVACY.md
   • TERMS.md

2. Content Integrity: The packaged SKILL.md and eval.md must match the canonical source files byte-for-byte. This ensures that the distributed documentation and evaluation criteria are identical to the repository versions, preventing drift between source and package.

3. Format Validation: The final output must be a valid ZIP file with proper structure and compression.

Any deviation from these requirements triggers an immediate build failure, protecting downstream users from malformed installations.

Running the Validation Locally

Execute the full build pipeline with validation using the following command from the repository root:

python scripts/build_plugin.py

On success, the script outputs the path to the generated archive:

Built dist/no-ai-slop-plugin-<version>.zip

To perform validation without creating persistent artifacts, use the --check flag:

python scripts/build_plugin.py --check

This command creates a temporary build directory, runs both validate_source() and validate_build(), then cleans up all generated files upon successful completion.

CI/CD Integration

For automated validation in GitHub Actions or similar CI environments:

- name: Build & validate No AI Slop plugin
  run: |
    python scripts/build_plugin.py --check

This ensures that every pull request passes the complete validation steps in the No AI Slop build process before merging.

Summary

• The build_plugin.py script enforces two-phase validation: source validation (lines 25-48) and build-artifact validation (lines 82-99).
• Source validation checks manifest schema compliance, prompt length constraints (≤3 entries, ≤128 characters), and the presence of required assets (SKILL.md, eval.md, PNG icon).
• Build-artifact validation verifies ZIP integrity, exact file manifests, and byte-for-byte equality of packaged documentation files.
• Use the --check flag to run validation without keeping output files, ideal for CI pipelines.
• Any validation failure triggers a SystemExit with a descriptive error, halting the build immediately.

Frequently Asked Questions

What triggers a validation failure in the No AI Slop build process?

A validation failure occurs when required manifest fields are missing, when defaultPrompt exceeds three entries or 128 characters per entry, when essential source files are absent, or when the final ZIP archive contains unexpected files or modified versions of SKILL.md and eval.md. Both validate_source() and validate_build() raise SystemExit upon detecting any inconsistency.

How does the --check flag differ from a standard build?

The --check flag executes the identical two-phase validation pipeline but removes the generated dist/ directory and ZIP archive after successful completion. Standard builds retain the output artifacts for distribution. This flag is designed for CI environments where validation confirmation is required but persistent build files are unnecessary.

Which manifest fields are mandatory for source validation?

The .codex-plugin/plugin.json must include top-level fields: name, version, description, author, skills, and interface. The interface object must contain displayName, shortDescription, longDescription, developerName, category, capabilities, and defaultPrompt. Absence of any single field causes validate_source() to abort the build.

Why does the build process verify byte-for-byte file matches?

The byte-for-byte verification of SKILL.md and eval.md ensures that the packaged plugin documentation exactly matches the source-controlled versions. This prevents accidental modifications, encoding changes, or stale cached copies from entering the distributed archive, guaranteeing that users receive the canonical rule sets and evaluation criteria defined in the repository.

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